Lines Matching refs:scope
37 #include "clang/Sema/Scope.h"
92 // argument expression are in scope and can hide namespace and
424 Scope *S) {
430 // scope. Declarations in different scopes have completely
455 // the same scope.
1208 bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *,
1784 Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D,
1942 // The user provided a superfluous scope specifier inside a class
2259 Scope *S,
2275 Scope *S,
2318 Scope *S,
2344 // Names in a mem-initializer-id are looked up in the scope of the
2345 // constructor's class and, if not found in that scope, are looked
2346 // up in the scope containing the constructor's definition.
2396 // When the scope specifier can refer to a member of an unknown
5003 // namespace scope, the constructor and destructor are used.
5637 void Sema::ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
5724 void Sema::ActOnReenterDeclaratorTemplateScope(Scope *S, DeclaratorDecl *D) {
5743 void Sema::ActOnReenterTemplateScope(Scope *S, Decl *D) {
5767 void Sema::ActOnStartDelayedMemberDeclarations(Scope *S, Decl *RecordD) {
5774 void Sema::ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *RecordD) {
5783 /// arguments. This action should enter the scope of the given
5785 /// name. However, it should not bring the parameters into scope;
5787 void Sema::ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *MethodD) {
5792 /// function parameter into scope for use in parsing later parts of
5795 void Sema::ActOnDelayedCXXMethodParameter(Scope *S, Decl *ParamD) {
5817 void Sema::ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *MethodD) {
6269 Decl *Sema::ActOnStartNamespaceDef(Scope *NamespcScope,
6283 Scope *DeclRegionScope = NamespcScope->getParent();
6295 // Since namespace names are unique in their scope, and we don't
6622 static bool TryNamespaceTypoCorrection(Sema &S, LookupResult &R, Scope *Sc,
6655 Decl *Sema::ActOnUsingDirective(Scope *S,
6667 while (S->getFlags() & Scope::TemplateParamScope)
6669 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
6702 // namespace can be used in the scope in which the
6737 void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) {
6738 // If the scope has an associated entity and the using directive is at
6739 // namespace or translation unit scope, add the UsingDirectiveDecl into
6746 // only to the end of the scope.
6751 Decl *Sema::ActOnUsingDeclaration(Scope *S,
6760 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
6972 UsingShadowDecl *Sema::BuildUsingShadowDecl(Scope *S,
7015 /// derived class scope, member functions in the derived class
7028 void Sema::HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow) {
7036 // ...and the scope, if applicable...
7084 NamedDecl *Sema::BuildUsingDeclaration(Scope *S, AccessSpecifier AS,
7103 // Do the redeclaration lookup in the current scope.
7119 assert(IsInstantiation && "no scope in non-instantiation");
7120 assert(CurContext->isRecord() && "scope not record in instantiation");
7267 "Using decl naming constructor doesn't have type in scope spec.");
7358 /// scope. If an error is found, diagnoses it and returns true.
7369 // If we weren't able to compute a valid scope, it must be a
7370 // dependent class scope.
7381 // The current scope is a record.
7491 Decl *Sema::ActOnAliasDeclaration(Scope *S,
7498 // Skip up to the relevant declaration scope.
7499 while (S->getFlags() & Scope::TemplateParamScope)
7501 assert((S->getFlags() & Scope::DeclScope) &&
7502 "got alias-declaration outside of declaration scope");
7562 // Only consider previous declarations in the same scope.
7635 Decl *Sema::ActOnNamespaceAliasDef(Scope *S,
7925 if (Scope *S = getScopeForContext(ClassDecl))
7942 SynthesizedFunctionScope Scope(*this, Constructor);
8280 SynthesizedFunctionScope Scope(*this, Constructor);
8391 // Introduce this destructor into its scope.
8392 if (Scope *S = getScopeForContext(ClassDecl))
8411 SynthesizedFunctionScope Scope(*this, Destructor);
8536 ExprResult Call = S.ActOnCallExpr(/*Scope=*/0, MemCpyRef.take(),
8656 ExprResult Call = S.BuildCallToMemberFunction(/*Scope=*/0,
8910 if (Scope *S = getScopeForContext(ClassDecl))
8994 SynthesizedFunctionScope Scope(*this, CopyAssignOperator);
9430 if (Scope *S = getScopeForContext(ClassDecl))
9455 SynthesizedFunctionScope Scope(*this, MoveAssignOperator);
9781 if (Scope *S = getScopeForContext(ClassDecl))
9806 SynthesizedFunctionScope Scope(*this, CopyConstructor);
9977 if (Scope *S = getScopeForContext(ClassDecl))
9995 SynthesizedFunctionScope Scope(*this, MoveConstructor);
10044 SynthesizedFunctionScope Scope(*this, Conv);
10077 SynthesizedFunctionScope Scope(*this, Conv);
10214 // Emit warning for non-trivial dtor in global scope (a real global,
10343 // namespace scope other than global scope or declared static in global
10344 // scope.
10374 // namespace scope other than global scope or declared static in global
10375 // scope.
10665 Decl *Sema::ActOnStartLinkageSpecification(Scope *S, SourceLocation ExternLoc,
10693 Decl *Sema::ActOnFinishLinkageSpecification(Scope *S,
10706 Decl *Sema::ActOnEmptyDeclaration(Scope *S,
10722 VarDecl *Sema::BuildExceptionDeclaration(Scope *S,
10796 EnterExpressionEvaluationContext scope(*this, PotentiallyEvaluated);
10843 Decl *Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D) {
10859 // The scope should be freshly made just for us. There is just no way
10882 // Add the exception declaration into this scope.
11012 /// Handle a friend tag declaration where the scope specifier was
11014 Decl *Sema::ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc,
11110 // Handle the case of a templated-scope friend class. e.g.
11138 /// class-head (i.e. no typedefs in the scope chain), template
11147 Decl *Sema::ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
11216 NamedDecl *Sema::ActOnFriendFunctionDecl(Scope *S, Declarator &D,
11250 scope (either before or after the class declaration granting
11257 // namespace scope are not considered.
11273 Scope *DCScope = S;
11280 // - There's no scope specifier, in which case we just go to the
11281 // appropriate scope and look for a function or function template
11283 // Recover from invalid scope qualifiers as if they just weren't there.
11295 // innermost enclosing non-class scope. For a friend function
11343 // unqualified, and the function has namespace scope.
11348 // - There's a non-dependent scope specifier, in which case we
11359 // Ignore things found implicitly in the wrong scope.
11361 // qualified scope would be nice...
11390 // unqualified, and the function has namespace scope.
11400 // - There's a scope specifier that does not match any template
11403 // - There's a scope specifier that does match some template
11410 // unqualified, and the function has namespace scope.
11431 // FIXME: This is an egregious hack to cope with cases where the scope stack
11434 Scope FakeDCScope(S, Scope::DeclScope, Diags);
11452 // Also update the scope-based lookup if the target context's
11453 // lookup context is in lexical scope.
11457 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
11490 // Mark templated-scope function declarations as unsupported.
11737 // the ParsingDeclSpec/ParsingDeclarator are still in scope.
11795 /// an initializer for the out-of-line declaration 'Dcl'. The scope
11796 /// is a fresh scope pushed for just this purpose.
11799 /// static data member of class X, names should be looked up in the scope of
11801 void Sema::ActOnCXXEnterDeclInitializer(Scope *S, Decl *D) {
11805 // We should only get called for declarations with scope specifiers, like:
11819 void Sema::ActOnCXXExitDeclInitializer(Scope *S, Decl *D) {
11833 DeclResult Sema::ActOnCXXConditionDeclaration(Scope *S, Declarator &D) {
12427 MSPropertyDecl *Sema::HandleMSProperty(Scope *S, RecordDecl *Record,
12506 // Don't introduce NewFD into scope; there's already something
12507 // with the same name in the same scope.
