name-lookup.c (259563) | name-lookup.c (260932) |
---|---|
1/* Definitions for C++ name lookup routines. 2 Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc. 3 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net> 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by --- 28 unchanged lines hidden (view full) --- 37 38struct scope_binding { 39 tree value; 40 tree type; 41}; 42#define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE } 43 44static cxx_scope *innermost_nonclass_level (void); | 1/* Definitions for C++ name lookup routines. 2 Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc. 3 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net> 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by --- 28 unchanged lines hidden (view full) --- 37 38struct scope_binding { 39 tree value; 40 tree type; 41}; 42#define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE } 43 44static cxx_scope *innermost_nonclass_level (void); |
45static tree select_decl (const struct scope_binding *, int); | |
46static cxx_binding *binding_for_name (cxx_scope *, tree); 47static tree lookup_name_innermost_nonclass_level (tree); 48static tree push_overloaded_decl (tree, int, bool); 49static bool lookup_using_namespace (tree, struct scope_binding *, tree, 50 tree, int); 51static bool qualified_lookup_using_namespace (tree, tree, 52 struct scope_binding *, int); 53static tree lookup_type_current_level (tree); --- 2041 unchanged lines hidden (view full) --- 2095 return; 2096 2097 if (!decls.value && !decls.type) 2098 { 2099 error ("%qD not declared", name); 2100 return; 2101 } 2102 | 45static cxx_binding *binding_for_name (cxx_scope *, tree); 46static tree lookup_name_innermost_nonclass_level (tree); 47static tree push_overloaded_decl (tree, int, bool); 48static bool lookup_using_namespace (tree, struct scope_binding *, tree, 49 tree, int); 50static bool qualified_lookup_using_namespace (tree, tree, 51 struct scope_binding *, int); 52static tree lookup_type_current_level (tree); --- 2041 unchanged lines hidden (view full) --- 2094 return; 2095 2096 if (!decls.value && !decls.type) 2097 { 2098 error ("%qD not declared", name); 2099 return; 2100 } 2101 |
2102 /* LLVM LOCAL begin mainline */ 2103 /* Shift the old and new bindings around so we're comparing class and 2104 enumeration names to each other. */ 2105 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval)) 2106 { 2107 oldtype = oldval; 2108 oldval = NULL_TREE; 2109 } 2110 2111 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value)) 2112 { 2113 decls.type = decls.value; 2114 decls.value = NULL_TREE; 2115 } 2116 /* LLVM LOCAL end mainline */ 2117 |
|
2103 /* It is impossible to overload a built-in function; any explicit 2104 declaration eliminates the built-in declaration. So, if OLDVAL 2105 is a built-in, then we can just pretend it isn't there. */ 2106 if (oldval 2107 && TREE_CODE (oldval) == FUNCTION_DECL 2108 && DECL_ANTICIPATED (oldval) 2109 && !DECL_HIDDEN_FRIEND_P (oldval)) 2110 oldval = NULL_TREE; 2111 | 2118 /* It is impossible to overload a built-in function; any explicit 2119 declaration eliminates the built-in declaration. So, if OLDVAL 2120 is a built-in, then we can just pretend it isn't there. */ 2121 if (oldval 2122 && TREE_CODE (oldval) == FUNCTION_DECL 2123 && DECL_ANTICIPATED (oldval) 2124 && !DECL_HIDDEN_FRIEND_P (oldval)) 2125 oldval = NULL_TREE; 2126 |
2112 /* Check for using functions. */ 2113 if (decls.value && is_overloaded_fn (decls.value)) | 2127 /* LLVM LOCAL begin mainline */ 2128 if (decls.value) |
2114 { | 2129 { |
2115 tree tmp, tmp1; 2116 2117 if (oldval && !is_overloaded_fn (oldval)) | 2130 /* Check for using functions. */ 2131 if (is_overloaded_fn (decls.value)) |
2118 { | 2132 { |
2119 if (!DECL_IMPLICIT_TYPEDEF_P (oldval)) 2120 error ("%qD is already declared in this scope", name); 2121 oldval = NULL_TREE; 2122 } | 2133 tree tmp, tmp1; |
2123 | 2134 |
2124 *newval = oldval; 2125 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp)) 2126 { 2127 tree new_fn = OVL_CURRENT (tmp); | 2135 if (oldval && !is_overloaded_fn (oldval)) 2136 { 2137 error ("%qD is already declared in this scope", name); 2138 oldval = NULL_TREE; 2139 } |
2128 | 2140 |
2129 /* [namespace.udecl] 2130 2131 If a function declaration in namespace scope or block 2132 scope has the same name and the same parameter types as a 2133 function introduced by a using declaration the program is 2134 ill-formed. */ 2135 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1)) | 2141 *newval = oldval; 2142 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp)) |
2136 { | 2143 { |
2137 tree old_fn = OVL_CURRENT (tmp1); | 2144 tree new_fn = OVL_CURRENT (tmp); |
2138 | 2145 |
2139 if (new_fn == old_fn) 2140 /* The function already exists in the current namespace. */ 2141 break; 2142 else if (OVL_USED (tmp1)) 2143 continue; /* this is a using decl */ 2144 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)), 2145 TYPE_ARG_TYPES (TREE_TYPE (old_fn)))) | 2146 /* [namespace.udecl] 2147 2148 If a function declaration in namespace scope or block 2149 scope has the same name and the same parameter types as a 2150 function introduced by a using declaration the program is 2151 ill-formed. */ 2152 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1)) |
2146 { | 2153 { |
2147 gcc_assert (!DECL_ANTICIPATED (old_fn) 2148 || DECL_HIDDEN_FRIEND_P (old_fn)); | 2154 tree old_fn = OVL_CURRENT (tmp1); |
2149 | 2155 |
2150 /* There was already a non-using declaration in 2151 this scope with the same parameter types. If both 2152 are the same extern "C" functions, that's ok. */ 2153 if (decls_match (new_fn, old_fn)) | 2156 if (new_fn == old_fn) 2157 /* The function already exists in the current namespace. */ |
2154 break; | 2158 break; |
2155 else | 2159 else if (OVL_USED (tmp1)) 2160 continue; /* this is a using decl */ 2161 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)), 2162 TYPE_ARG_TYPES (TREE_TYPE (old_fn)))) |
2156 { | 2163 { |
2157 error ("%qD is already declared in this scope", name); 2158 break; | 2164 gcc_assert (!DECL_ANTICIPATED (old_fn) 2165 || DECL_HIDDEN_FRIEND_P (old_fn)); 2166 2167 /* There was already a non-using declaration in 2168 this scope with the same parameter types. If both 2169 are the same extern "C" functions, that's ok. */ 2170 if (decls_match (new_fn, old_fn)) 2171 break; 2172 else 2173 { 2174 error ("%qD is already declared in this scope", name); 2175 break; 2176 } |
2159 } 2160 } | 2177 } 2178 } |
2161 } | |
2162 | 2179 |
2163 /* If we broke out of the loop, there's no reason to add 2164 this function to the using declarations for this 2165 scope. */ 2166 if (tmp1) 2167 continue; | 2180 /* If we broke out of the loop, there's no reason to add 2181 this function to the using declarations for this 2182 scope. */ 2183 if (tmp1) 2184 continue; |
2168 | 2185 |
2169 /* If we are adding to an existing OVERLOAD, then we no 2170 longer know the type of the set of functions. */ 2171 if (*newval && TREE_CODE (*newval) == OVERLOAD) 2172 TREE_TYPE (*newval) = unknown_type_node; 2173 /* Add this new function to the set. */ 2174 *newval = build_overload (OVL_CURRENT (tmp), *newval); 2175 /* If there is only one function, then we use its type. (A 2176 using-declaration naming a single function can be used in 2177 contexts where overload resolution cannot be 2178 performed.) */ 2179 if (TREE_CODE (*newval) != OVERLOAD) 2180 { 2181 *newval = ovl_cons (*newval, NULL_TREE); 2182 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp)); | 2186 /* If we are adding to an existing OVERLOAD, then we no 2187 longer know the type of the set of functions. */ 2188 if (*newval && TREE_CODE (*newval) == OVERLOAD) 2189 TREE_TYPE (*newval) = unknown_type_node; 2190 /* Add this new function to the set. */ 2191 *newval = build_overload (OVL_CURRENT (tmp), *newval); 2192 /* If there is only one function, then we use its type. (A 2193 using-declaration naming a single function can be used in 2194 contexts where overload resolution cannot be 2195 performed.) */ 2196 if (TREE_CODE (*newval) != OVERLOAD) 2197 { 2198 *newval = ovl_cons (*newval, NULL_TREE); 2199 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp)); 2200 } 2201 OVL_USED (*newval) = 1; |
2183 } | 2202 } |
2184 OVL_USED (*newval) = 1; | |
2185 } | 2203 } |
2204 else 2205 { 2206 *newval = decls.value; 2207 if (oldval && !decls_match (*newval, oldval)) 2208 error ("%qD is already declared in this scope", name); 2209 } |
|
2186 } 2187 else | 2210 } 2211 else |
2212 *newval = oldval; 2213 2214 if (decls.type && TREE_CODE (decls.type) == TREE_LIST) |
|
2188 { | 2215 { |
2189 *newval = decls.value; 2190 if (oldval && !decls_match (*newval, oldval)) 2191 error ("%qD is already declared in this scope", name); | 2216 error ("reference to %qD is ambiguous", name); 2217 print_candidates (decls.type); |
2192 } | 2218 } |
2193 2194 *newtype = decls.type; 2195 if (oldtype && *newtype && !same_type_p (oldtype, *newtype)) | 2219 else |
2196 { | 2220 { |
2197 error ("using declaration %qD introduced ambiguous type %qT", 2198 name, oldtype); 2199 return; | 2221 *newtype = decls.type; 2222 if (oldtype && *newtype && !decls_match (oldtype, *newtype)) 2223 error ("%qD is already declared in this scope", name); |
2200 } | 2224 } |
2225 2226 /* If *newval is empty, shift any class or enumeration name down. */ 2227 if (!*newval) 2228 { 2229 *newval = *newtype; 2230 *newtype = NULL_TREE; 2231 } 2232 /* LLVM LOCAL end mainline */ |
|
2201} 2202 2203/* Process a using-declaration at function scope. */ 2204 2205void 2206do_local_using_decl (tree decl, tree scope, tree name) 2207{ 2208 tree oldval, oldtype, newval, newtype; --- 1277 unchanged lines hidden (view full) --- 3486/* This should return an error not all definitions define functions. 3487 It is not an error if we find two functions with exactly the 3488 same signature, only if these are selected in overload resolution. 3489 old is the current set of bindings, new the freshly-found binding. 3490 XXX Do we want to give *all* candidates in case of ambiguity? 3491 XXX In what way should I treat extern declarations? 3492 XXX I don't want to repeat the entire duplicate_decls here */ 3493 | 2233} 2234 2235/* Process a using-declaration at function scope. */ 2236 2237void 2238do_local_using_decl (tree decl, tree scope, tree name) 2239{ 2240 tree oldval, oldtype, newval, newtype; --- 1277 unchanged lines hidden (view full) --- 3518/* This should return an error not all definitions define functions. 3519 It is not an error if we find two functions with exactly the 3520 same signature, only if these are selected in overload resolution. 3521 old is the current set of bindings, new the freshly-found binding. 3522 XXX Do we want to give *all* candidates in case of ambiguity? 3523 XXX In what way should I treat extern declarations? 3524 XXX I don't want to repeat the entire duplicate_decls here */ 3525 |
3526/* LLVM LOCAL begin mainline */ |
|
3494static void | 3527static void |
3495ambiguous_decl (tree name, struct scope_binding *old, cxx_binding *new, 3496 int flags) | 3528ambiguous_decl (struct scope_binding *old, cxx_binding *new, int flags) |
3497{ 3498 tree val, type; 3499 gcc_assert (old != NULL); | 3529{ 3530 tree val, type; 3531 gcc_assert (old != NULL); |
3532 3533 /* Copy the type. */ 3534 type = new->type; 3535 if (LOOKUP_NAMESPACES_ONLY (flags) 3536 || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN))) 3537 type = NULL_TREE; 3538 |
|
3500 /* Copy the value. */ 3501 val = new->value; 3502 if (val) | 3539 /* Copy the value. */ 3540 val = new->value; 3541 if (val) |
3503 switch (TREE_CODE (val)) 3504 { 3505 case TEMPLATE_DECL: 3506 /* If we expect types or namespaces, and not templates, 3507 or this is not a template class. */ 3508 if ((LOOKUP_QUALIFIERS_ONLY (flags) 3509 && !DECL_CLASS_TEMPLATE_P (val)) 3510 || hidden_name_p (val)) 3511 val = NULL_TREE; 3512 break; 3513 case TYPE_DECL: 3514 if (LOOKUP_NAMESPACES_ONLY (flags) || hidden_name_p (val)) 3515 val = NULL_TREE; 3516 break; 3517 case NAMESPACE_DECL: 3518 if (LOOKUP_TYPES_ONLY (flags)) 3519 val = NULL_TREE; 3520 break; 3521 case FUNCTION_DECL: 3522 /* Ignore built-in functions that are still anticipated. */ 3523 if (LOOKUP_QUALIFIERS_ONLY (flags) || hidden_name_p (val)) 3524 val = NULL_TREE; 3525 break; 3526 default: 3527 if (LOOKUP_QUALIFIERS_ONLY (flags)) 3528 val = NULL_TREE; 3529 } | 3542 { 3543 if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN)) 3544 val = NULL_TREE; 3545 else 3546 switch (TREE_CODE (val)) 3547 { 3548 case TEMPLATE_DECL: 3549 /* If we expect types or namespaces, and not templates, 3550 or this is not a template class. */ 3551 if ((LOOKUP_QUALIFIERS_ONLY (flags) 3552 && !DECL_CLASS_TEMPLATE_P (val))) 3553 val = NULL_TREE; 3554 break; 3555 case TYPE_DECL: 3556 if (LOOKUP_NAMESPACES_ONLY (flags) 3557 || (type && (flags & LOOKUP_PREFER_TYPES))) 3558 val = NULL_TREE; 3559 break; 3560 case NAMESPACE_DECL: 3561 if (LOOKUP_TYPES_ONLY (flags)) 3562 val = NULL_TREE; 3563 break; 3564 case FUNCTION_DECL: 3565 /* Ignore built-in functions that are still anticipated. */ 3566 if (LOOKUP_QUALIFIERS_ONLY (flags)) 3567 val = NULL_TREE; 3568 break; 3569 default: 3570 if (LOOKUP_QUALIFIERS_ONLY (flags)) 3571 val = NULL_TREE; 3572 } 3573 } |
3530 | 3574 |
3575 /* If val is hidden, shift down any class or enumeration name. */ 3576 if (!val) 3577 { 3578 val = type; 3579 type = NULL_TREE; 3580 } 3581 3582/* LLVM LOCAL end mainline */ |
|
3531 if (!old->value) 3532 old->value = val; 3533 else if (val && val != old->value) 3534 { 3535 if (is_overloaded_fn (old->value) && is_overloaded_fn (val)) 3536 old->value = merge_functions (old->value, val); 3537 else 3538 { 3539 old->value = tree_cons (NULL_TREE, old->value, | 3583 if (!old->value) 3584 old->value = val; 3585 else if (val && val != old->value) 3586 { 3587 if (is_overloaded_fn (old->value) && is_overloaded_fn (val)) 3588 old->value = merge_functions (old->value, val); 3589 else 3590 { 3591 old->value = tree_cons (NULL_TREE, old->value, |
3540 build_tree_list (NULL_TREE, new->value)); | 3592 build_tree_list (NULL_TREE, val)); |
3541 TREE_TYPE (old->value) = error_mark_node; 3542 } 3543 } | 3593 TREE_TYPE (old->value) = error_mark_node; 3594 } 3595 } |
3544 /* ... and copy the type. */ 3545 type = new->type; 3546 if (LOOKUP_NAMESPACES_ONLY (flags)) 3547 type = NULL_TREE; | 3596 3597 /* LLVM LOCAL begin mainline */ |
3548 if (!old->type) 3549 old->type = type; 3550 else if (type && old->type != type) 3551 { | 3598 if (!old->type) 3599 old->type = type; 3600 else if (type && old->type != type) 3601 { |
3552 if (flags & LOOKUP_COMPLAIN) 3553 { 3554 error ("%qD denotes an ambiguous type",name); 3555 error ("%J first type here", TYPE_MAIN_DECL (old->type)); 3556 error ("%J other type here", TYPE_MAIN_DECL (type)); 3557 } | 3602 old->type = tree_cons (NULL_TREE, old->type, 3603 build_tree_list (NULL_TREE, type)); 3604 TREE_TYPE (old->type) = error_mark_node; |
3558 } | 3605 } |
3606 /* LLVM LOCAL end mainline */ |
|
3559} 3560 3561/* Return the declarations that are members of the namespace NS. */ 3562 3563tree 3564cp_namespace_decls (tree ns) 3565{ 3566 return NAMESPACE_LEVEL (ns)->names; --- 72 unchanged lines hidden (view full) --- 3639 n = build_overload (OVL_CURRENT (o), n); 3640 fns = n; 3641 } 3642 } 3643 3644 return fns; 3645} 3646 | 3607} 3608 3609/* Return the declarations that are members of the namespace NS. */ 3610 3611tree 3612cp_namespace_decls (tree ns) 3613{ 3614 return NAMESPACE_LEVEL (ns)->names; --- 72 unchanged lines hidden (view full) --- 3687 n = build_overload (OVL_CURRENT (o), n); 3688 fns = n; 3689 } 3690 } 3691 3692 return fns; 3693} 3694 |
3647/* Select the right _DECL from multiple choices. */ 3648 3649static tree 3650select_decl (const struct scope_binding *binding, int flags) 3651{ 3652 tree val; 3653 val = binding->value; 3654 3655 timevar_push (TV_NAME_LOOKUP); 3656 if (LOOKUP_NAMESPACES_ONLY (flags)) 3657 { 3658 /* We are not interested in types. */ 3659 if (val && (TREE_CODE (val) == NAMESPACE_DECL 3660 || TREE_CODE (val) == TREE_LIST)) 3661 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val); 3662 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE); 3663 } 3664 3665 /* If looking for a type, or if there is no non-type binding, select 3666 the value binding. */ 3667 if (binding->type && (!val || (flags & LOOKUP_PREFER_TYPES))) 3668 val = binding->type; 3669 /* Don't return non-types if we really prefer types. */ 3670 else if (val && LOOKUP_TYPES_ONLY (flags) 3671 && ! DECL_DECLARES_TYPE_P (val)) 3672 val = NULL_TREE; 3673 3674 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val); 3675} 3676 | |
3677/* Unscoped lookup of a global: iterate over current namespaces, 3678 considering using-directives. */ 3679 3680static tree 3681unqualified_namespace_lookup (tree name, int flags) 3682{ 3683 tree initial = current_decl_namespace (); 3684 tree scope = initial; 3685 tree siter; 3686 struct cp_binding_level *level; 3687 tree val = NULL_TREE; | 3695/* Unscoped lookup of a global: iterate over current namespaces, 3696 considering using-directives. */ 3697 3698static tree 3699unqualified_namespace_lookup (tree name, int flags) 3700{ 3701 tree initial = current_decl_namespace (); 3702 tree scope = initial; 3703 tree siter; 3704 struct cp_binding_level *level; 3705 tree val = NULL_TREE; |
3688 struct scope_binding binding = EMPTY_SCOPE_BINDING; | |
3689 3690 timevar_push (TV_NAME_LOOKUP); 3691 3692 for (; !val; scope = CP_DECL_CONTEXT (scope)) 3693 { | 3706 3707 timevar_push (TV_NAME_LOOKUP); 3708 3709 for (; !val; scope = CP_DECL_CONTEXT (scope)) 3710 { |
3711 struct scope_binding binding = EMPTY_SCOPE_BINDING; |
|
3694 cxx_binding *b = 3695 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name); 3696 3697 if (b) | 3712 cxx_binding *b = 3713 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name); 3714 3715 if (b) |
3698 { 3699 if (b->value 3700 && ((flags & LOOKUP_HIDDEN) || !hidden_name_p (b->value))) 3701 binding.value = b->value; 3702 binding.type = b->type; 3703 } | 3716 /* LLVM LOCAL mainline */ 3717 ambiguous_decl (&binding, b, flags); |
3704 3705 /* Add all _DECLs seen through local using-directives. */ 3706 for (level = current_binding_level; 3707 level->kind != sk_namespace; 3708 level = level->level_chain) 3709 if (!lookup_using_namespace (name, &binding, level->using_directives, 3710 scope, flags)) 3711 /* Give up because of error. */ --- 8 unchanged lines hidden (view full) --- 3720 DECL_NAMESPACE_USING (siter), 3721 scope, flags)) 3722 /* Give up because of error. */ 3723 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); 3724 if (siter == scope) break; 3725 siter = CP_DECL_CONTEXT (siter); 3726 } 3727 | 3718 3719 /* Add all _DECLs seen through local using-directives. */ 3720 for (level = current_binding_level; 3721 level->kind != sk_namespace; 3722 level = level->level_chain) 3723 if (!lookup_using_namespace (name, &binding, level->using_directives, 3724 scope, flags)) 3725 /* Give up because of error. */ --- 8 unchanged lines hidden (view full) --- 3734 DECL_NAMESPACE_USING (siter), 3735 scope, flags)) 3736 /* Give up because of error. */ 3737 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); 3738 if (siter == scope) break; 3739 siter = CP_DECL_CONTEXT (siter); 3740 } 3741 |
3728 val = select_decl (&binding, flags); | 3742 val = binding.value; |
3729 if (scope == global_namespace) 3730 break; 3731 } 3732 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val); 3733} 3734 3735/* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL 3736 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type --- 13 unchanged lines hidden (view full) --- 3750 if (TREE_CODE (scope) == NAMESPACE_DECL) 3751 { 3752 struct scope_binding binding = EMPTY_SCOPE_BINDING; 3753 3754 flags |= LOOKUP_COMPLAIN; 3755 if (is_type_p) 3756 flags |= LOOKUP_PREFER_TYPES; 3757 if (qualified_lookup_using_namespace (name, scope, &binding, flags)) | 3743 if (scope == global_namespace) 3744 break; 3745 } 3746 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val); 3747} 3748 3749/* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL 3750 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type --- 13 unchanged lines hidden (view full) --- 3764 if (TREE_CODE (scope) == NAMESPACE_DECL) 3765 { 3766 struct scope_binding binding = EMPTY_SCOPE_BINDING; 3767 3768 flags |= LOOKUP_COMPLAIN; 3769 if (is_type_p) 3770 flags |= LOOKUP_PREFER_TYPES; 3771 if (qualified_lookup_using_namespace (name, scope, &binding, flags)) |
3758 t = select_decl (&binding, flags); | 3772 t = binding.value; |
3759 } 3760 else if (is_aggr_type (scope, complain)) 3761 t = lookup_member (scope, name, 2, is_type_p); 3762 3763 if (!t) 3764 return error_mark_node; 3765 return t; 3766} --- 16 unchanged lines hidden (view full) --- 3783 for (iter = usings; iter; iter = TREE_CHAIN (iter)) 3784 if (TREE_VALUE (iter) == scope) 3785 { 3786 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter)); 3787 cxx_binding *val1 = 3788 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name); 3789 /* Resolve ambiguities. */ 3790 if (val1) | 3773 } 3774 else if (is_aggr_type (scope, complain)) 3775 t = lookup_member (scope, name, 2, is_type_p); 3776 3777 if (!t) 3778 return error_mark_node; 3779 return t; 3780} --- 16 unchanged lines hidden (view full) --- 3797 for (iter = usings; iter; iter = TREE_CHAIN (iter)) 3798 if (TREE_VALUE (iter) == scope) 3799 { 3800 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter)); 3801 cxx_binding *val1 = 3802 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name); 3803 /* Resolve ambiguities. */ 3804 if (val1) |
3791 ambiguous_decl (name, val, val1, flags); | 3805 /* LLVM LOCAL mainline */ 3806 ambiguous_decl (val, val1, flags); |
3792 } 3793 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node); 3794} 3795 3796/* [namespace.qual] 3797 Accepts the NAME to lookup and its qualifying SCOPE. 3798 Returns the name/type pair found into the cxx_binding *RESULT, 3799 or false on error. */ --- 12 unchanged lines hidden (view full) --- 3812 /* Look through namespace aliases. */ 3813 scope = ORIGINAL_NAMESPACE (scope); 3814 while (scope && result->value != error_mark_node) 3815 { 3816 cxx_binding *binding = 3817 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name); 3818 seen = tree_cons (scope, NULL_TREE, seen); 3819 if (binding) | 3807 } 3808 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node); 3809} 3810 3811/* [namespace.qual] 3812 Accepts the NAME to lookup and its qualifying SCOPE. 3813 Returns the name/type pair found into the cxx_binding *RESULT, 3814 or false on error. */ --- 12 unchanged lines hidden (view full) --- 3827 /* Look through namespace aliases. */ 3828 scope = ORIGINAL_NAMESPACE (scope); 3829 while (scope && result->value != error_mark_node) 3830 { 3831 cxx_binding *binding = 3832 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name); 3833 seen = tree_cons (scope, NULL_TREE, seen); 3834 if (binding) |
3820 ambiguous_decl (name, result, binding, flags); | 3835 /* LLVM LOCAL mainline */ 3836 ambiguous_decl (result, binding, flags); |
3821 3822 /* Consider strong using directives always, and non-strong ones 3823 if we haven't found a binding yet. ??? Shouldn't we consider 3824 non-strong ones if the initial RESULT is non-NULL, but the 3825 binding in the given namespace is? */ 3826 for (usings = DECL_NAMESPACE_USING (scope); usings; 3827 usings = TREE_CHAIN (usings)) 3828 /* If this was a real directive, and we have not seen it. */ --- 1382 unchanged lines hidden --- | 3837 3838 /* Consider strong using directives always, and non-strong ones 3839 if we haven't found a binding yet. ??? Shouldn't we consider 3840 non-strong ones if the initial RESULT is non-NULL, but the 3841 binding in the given namespace is? */ 3842 for (usings = DECL_NAMESPACE_USING (scope); usings; 3843 usings = TREE_CHAIN (usings)) 3844 /* If this was a real directive, and we have not seen it. */ --- 1382 unchanged lines hidden --- |