clang 20.0.0git
SemaCodeCompletion.h
Go to the documentation of this file.
1//===----- SemaCodeCompletion.h ------ Code completion support ------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8/// \file
9/// This file declares facilities that support code completion.
10///
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_SEMA_SEMACODECOMPLETION_H
14#define LLVM_CLANG_SEMA_SEMACODECOMPLETION_H
15
16#include "clang/AST/ASTFwd.h"
17#include "clang/AST/Type.h"
20#include "clang/Basic/LLVM.h"
24#include "clang/Sema/DeclSpec.h"
28#include "clang/Sema/SemaBase.h"
29#include "llvm/ADT/StringRef.h"
30#include <optional>
31
32namespace clang {
33class DeclGroupRef;
34class MacroInfo;
35class Scope;
36class TemplateName;
37
39public:
40 SemaCodeCompletion(Sema &S, CodeCompleteConsumer *CompletionConsumer);
41
44
45 /// Code-completion consumer.
48
49 /// Describes the context in which code completion occurs.
51 /// Code completion occurs at top-level or namespace context.
53 /// Code completion occurs within a class, struct, or union.
55 /// Code completion occurs within an Objective-C interface, protocol,
56 /// or category.
58 /// Code completion occurs within an Objective-C implementation or
59 /// category implementation
61 /// Code completion occurs within the list of instance variables
62 /// in an Objective-C interface, protocol, category, or implementation.
64 /// Code completion occurs following one or more template
65 /// headers.
67 /// Code completion occurs following one or more template
68 /// headers within a class.
70 /// Code completion occurs within an expression.
72 /// Code completion occurs within a statement, which may
73 /// also be an expression or a declaration.
75 /// Code completion occurs at the beginning of the
76 /// initialization statement (or expression) in a for loop.
78 /// Code completion occurs within the condition of an if,
79 /// while, switch, or for statement.
81 /// Code completion occurs within the body of a function on a
82 /// recovery path, where we do not have a specific handle on our position
83 /// in the grammar.
85 /// Code completion occurs where only a type is permitted.
87 /// Code completion occurs in a parenthesized expression, which
88 /// might also be a type cast.
90 /// Code completion occurs within a sequence of declaration
91 /// specifiers within a function, method, or block.
93 /// Code completion occurs at top-level in a REPL session
95 };
96
99 ParserCompletionContext CompletionContext);
100 void CodeCompleteDeclSpec(Scope *S, DeclSpec &DS, bool AllowNonIdentifiers,
101 bool AllowNestedNameSpecifiers);
102
103 struct CodeCompleteExpressionData;
104 void CodeCompleteExpression(Scope *S, const CodeCompleteExpressionData &Data);
105 void CodeCompleteExpression(Scope *S, QualType PreferredType,
106 bool IsParenthesized = false);
107 void CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base, Expr *OtherOpBase,
108 SourceLocation OpLoc, bool IsArrow,
109 bool IsBaseExprStatement,
110 QualType PreferredType);
112 QualType PreferredType);
113 void CodeCompleteTag(Scope *S, unsigned TagSpec);
116 const VirtSpecifiers *VS = nullptr);
118 void CodeCompleteCase(Scope *S);
120 Attribute,
121 Scope,
122 None,
123 };
127 const IdentifierInfo *Scope = nullptr);
128 /// Determines the preferred type of the current function argument, by
129 /// examining the signatures of all possible overloads.
130 /// Returns null if unknown or ambiguous, or if code completion is off.
131 ///
132 /// If the code completion point has been reached, also reports the function
133 /// signatures that were considered.
134 ///
135 /// FIXME: rename to GuessCallArgumentType to reduce confusion.
137 SourceLocation OpenParLoc);
139 ArrayRef<Expr *> Args,
140 SourceLocation OpenParLoc,
141 bool Braced);
143 Decl *ConstructorDecl, CXXScopeSpec SS, ParsedType TemplateTypeTy,
144 ArrayRef<Expr *> ArgExprs, IdentifierInfo *II, SourceLocation OpenParLoc,
145 bool Braced);
149 /// Trigger code completion for a record of \p BaseType. \p InitExprs are
150 /// expressions in the initializer list seen so far and \p D is the current
151 /// Designation being parsed.
152 void CodeCompleteDesignator(const QualType BaseType,
153 llvm::ArrayRef<Expr *> InitExprs,
154 const Designation &D);
155 void CodeCompleteAfterIf(Scope *S, bool IsBracedThen);
156
157 void CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS, bool EnteringContext,
158 bool IsUsingDeclaration, QualType BaseType,
159 QualType PreferredType);
160 void CodeCompleteUsing(Scope *S);
166 Decl *Constructor, ArrayRef<CXXCtorInitializer *> Initializers);
167
169 bool AfterAmpersand);
171
180 bool IsParameter);
184 bool AtArgumentExpression);
187 bool AtArgumentExpression,
188 bool IsSuper = false);
190 Scope *S, Expr *Receiver, ArrayRef<const IdentifierInfo *> SelIdents,
191 bool AtArgumentExpression, ObjCInterfaceDecl *Super = nullptr);
195 void
201 SourceLocation ClassNameLoc);
204 SourceLocation ClassNameLoc);
206 IdentifierInfo *ClassName,
207 SourceLocation ClassNameLoc);
210 IdentifierInfo *PropertyName);
212 std::optional<bool> IsInstanceMethod,
213 ParsedType ReturnType);
215 Scope *S, bool IsInstanceMethod, bool AtParameterName,
216 ParsedType ReturnType, ArrayRef<const IdentifierInfo *> SelIdents);
218 const IdentifierInfo &ClassName,
219 SourceLocation ClassNameLoc,
220 bool IsBaseExprStatement);
221 void CodeCompletePreprocessorDirective(bool InConditional);
223 void CodeCompletePreprocessorMacroName(bool IsDefinition);
227 unsigned Argument);
228 void CodeCompleteIncludedFile(llvm::StringRef Dir, bool IsAngled);
231 void
233 CodeCompletionTUInfo &CCTUInfo,
235};
236
237} // namespace clang
238
239#endif // LLVM_CLANG_SEMA_SEMACODECOMPLETION_H
Forward declaration of all AST node types.
const Decl * D
IndirectLocalPath & Path
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
SourceLocation Loc
Definition: SemaObjC.cpp:759
Defines the clang::SourceLocation class and associated facilities.
C Language Family Type Representation.
Syntax
The style used to specify an attribute.
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:74
Abstract interface for a consumer of code-completion information.
An allocator used specifically for the purpose of code completion.
Captures information about "declaration specifiers".
Definition: DeclSpec.h:247
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1903
Designation - Represent a full designation, which is a sequence of designators.
Definition: Designator.h:208
This represents one expression.
Definition: Expr.h:110
One of these records is kept for each identifier that is lexed.
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:39
Captures information about "declaration specifiers" specific to Objective-C.
Definition: DeclSpec.h:900
Represents an ObjC class declaration.
Definition: DeclObjC.h:1153
A (possibly-)qualified type.
Definition: Type.h:929
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:41
void CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver, ArrayRef< const IdentifierInfo * > SelIdents, bool AtArgumentExpression, ObjCInterfaceDecl *Super=nullptr)
void CodeCompleteObjCPropertySynthesizeIvar(Scope *S, IdentifierInfo *PropertyName)
void CodeCompleteAttribute(AttributeCommonInfo::Syntax Syntax, AttributeCompletion Completion=AttributeCompletion::Attribute, const IdentifierInfo *Scope=nullptr)
QualType ProduceTemplateArgumentSignatureHelp(TemplateTy, ArrayRef< ParsedTemplateArgument >, SourceLocation LAngleLoc)
QualType ProduceCtorInitMemberSignatureHelp(Decl *ConstructorDecl, CXXScopeSpec SS, ParsedType TemplateTypeTy, ArrayRef< Expr * > ArgExprs, IdentifierInfo *II, SourceLocation OpenParLoc, bool Braced)
void CodeCompleteObjCClassForwardDecl(Scope *S)
void CodeCompleteNamespaceAliasDecl(Scope *S)
void GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo, SmallVectorImpl< CodeCompletionResult > &Results)
void CodeCompleteObjCAtStatement(Scope *S)
void CodeCompleteObjCMessageReceiver(Scope *S)
void CodeCompleteOperatorName(Scope *S)
void CodeCompleteUsingDirective(Scope *S)
void CodeCompleteObjCProtocolDecl(Scope *S)
void CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS)
ParserCompletionContext
Describes the context in which code completion occurs.
@ PCC_LocalDeclarationSpecifiers
Code completion occurs within a sequence of declaration specifiers within a function,...
@ PCC_MemberTemplate
Code completion occurs following one or more template headers within a class.
@ PCC_Condition
Code completion occurs within the condition of an if, while, switch, or for statement.
@ PCC_ParenthesizedExpression
Code completion occurs in a parenthesized expression, which might also be a type cast.
@ PCC_TopLevelOrExpression
Code completion occurs at top-level in a REPL session.
@ PCC_Class
Code completion occurs within a class, struct, or union.
@ PCC_ForInit
Code completion occurs at the beginning of the initialization statement (or expression) in a for loop...
@ PCC_Type
Code completion occurs where only a type is permitted.
@ PCC_ObjCImplementation
Code completion occurs within an Objective-C implementation or category implementation.
@ PCC_ObjCInterface
Code completion occurs within an Objective-C interface, protocol, or category.
@ PCC_Namespace
Code completion occurs at top-level or namespace context.
@ PCC_Expression
Code completion occurs within an expression.
@ PCC_RecoveryInFunction
Code completion occurs within the body of a function on a recovery path, where we do not have a speci...
@ PCC_ObjCInstanceVariableList
Code completion occurs within the list of instance variables in an Objective-C interface,...
@ PCC_Template
Code completion occurs following one or more template headers.
@ PCC_Statement
Code completion occurs within a statement, which may also be an expression or a declaration.
void CodeCompleteObjCAtDirective(Scope *S)
void CodeCompleteObjCPropertySetter(Scope *S)
void CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro, bool AfterAmpersand)
void CodeCompleteObjCImplementationCategory(Scope *S, IdentifierInfo *ClassName, SourceLocation ClassNameLoc)
void CodeCompleteObjCInterfaceDecl(Scope *S)
void CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D, const VirtSpecifiers *VS=nullptr)
void CodeCompletePreprocessorMacroName(bool IsDefinition)
void CodeCompleteInPreprocessorConditionalExclusion(Scope *S)
void CodeCompleteObjCAtExpression(Scope *S)
void CodeCompleteTypeQualifiers(DeclSpec &DS)
void CodeCompleteObjCPropertyDefinition(Scope *S)
void CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc, ArrayRef< const IdentifierInfo * > SelIdents, bool AtArgumentExpression)
CodeCompleteConsumer * CodeCompleter
Code-completion consumer.
void CodeCompleteAfterFunctionEquals(Declarator &D)
QualType ProduceConstructorSignatureHelp(QualType Type, SourceLocation Loc, ArrayRef< Expr * > Args, SourceLocation OpenParLoc, bool Braced)
OpaquePtr< TemplateName > TemplateTy
void CodeCompleteExpression(Scope *S, const CodeCompleteExpressionData &Data)
Perform code-completion in an expression context when we know what type we're looking for.
QualType ProduceCallSignatureHelp(Expr *Fn, ArrayRef< Expr * > Args, SourceLocation OpenParLoc)
Determines the preferred type of the current function argument, by examining the signatures of all po...
void CodeCompleteObjCMethodDeclSelector(Scope *S, bool IsInstanceMethod, bool AtParameterName, ParsedType ReturnType, ArrayRef< const IdentifierInfo * > SelIdents)
void CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS, bool EnteringContext, bool IsUsingDeclaration, QualType BaseType, QualType PreferredType)
void CodeCompleteIncludedFile(llvm::StringRef Dir, bool IsAngled)
void CodeCompletePreprocessorMacroArgument(Scope *S, IdentifierInfo *Macro, MacroInfo *MacroInfo, unsigned Argument)
void CodeCompleteModuleImport(SourceLocation ImportLoc, ModuleIdPath Path)
void CodeCompleteObjCInterfaceCategory(Scope *S, IdentifierInfo *ClassName, SourceLocation ClassNameLoc)
void CodeCompleteObjCSelector(Scope *S, ArrayRef< const IdentifierInfo * > SelIdents)
void CodeCompleteConstructorInitializer(Decl *Constructor, ArrayRef< CXXCtorInitializer * > Initializers)
void CodeCompleteObjCImplementationDecl(Scope *S)
void CodeCompleteAfterIf(Scope *S, bool IsBracedThen)
void CodeCompleteObjCMethodDecl(Scope *S, std::optional< bool > IsInstanceMethod, ParsedType ReturnType)
void CodeCompleteOrdinaryName(Scope *S, ParserCompletionContext CompletionContext)
OpaquePtr< DeclGroupRef > DeclGroupPtrTy
void CodeCompleteObjCProtocolReferences(ArrayRef< IdentifierLocPair > Protocols)
void CodeCompleteObjCClassPropertyRefExpr(Scope *S, const IdentifierInfo &ClassName, SourceLocation ClassNameLoc, bool IsBaseExprStatement)
void CodeCompleteInitializer(Scope *S, Decl *D)
void CodeCompleteNamespaceDecl(Scope *S)
void CodeCompleteDesignator(const QualType BaseType, llvm::ArrayRef< Expr * > InitExprs, const Designation &D)
Trigger code completion for a record of BaseType.
void CodeCompletePreprocessorDirective(bool InConditional)
void CodeCompleteBracketDeclarator(Scope *S)
void CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName, SourceLocation ClassNameLoc)
void CodeCompleteObjCAtVisibility(Scope *S)
void CodeCompleteTag(Scope *S, unsigned TagSpec)
void CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver, ArrayRef< const IdentifierInfo * > SelIdents, bool AtArgumentExpression, bool IsSuper=false)
void CodeCompleteObjCForCollection(Scope *S, DeclGroupPtrTy IterationVar)
void CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base, Expr *OtherOpBase, SourceLocation OpLoc, bool IsArrow, bool IsBaseExprStatement, QualType PreferredType)
void CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS, bool IsParameter)
void CodeCompleteObjCPropertyGetter(Scope *S)
void CodeCompleteDeclSpec(Scope *S, DeclSpec &DS, bool AllowNonIdentifiers, bool AllowNestedNameSpecifiers)
void CodeCompletePostfixExpression(Scope *S, ExprResult LHS, QualType PreferredType)
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:464
Encodes a location in the source.
The base class of the type hierarchy.
Definition: Type.h:1828
Represents a C++11 virt-specifier-seq.
Definition: DeclSpec.h:2783
The JSON file list parser is used to communicate input to InstallAPI.
Represents a complete lambda introducer.
Definition: DeclSpec.h:2835