mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
140 lines
5.1 KiB
C++
140 lines
5.1 KiB
C++
//===--- ArgumentCompletion.h -----------------------------------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2022 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef SWIFT_IDE_ARGUMENTCOMPLETION_H
|
|
#define SWIFT_IDE_ARGUMENTCOMPLETION_H
|
|
|
|
#include "swift/IDE/CodeCompletionConsumer.h"
|
|
#include "swift/IDE/CodeCompletionContext.h"
|
|
#include "swift/IDE/PossibleParamInfo.h"
|
|
#include "swift/IDE/TypeCheckCompletionCallback.h"
|
|
|
|
namespace swift {
|
|
namespace ide {
|
|
|
|
struct Signature;
|
|
|
|
class ArgumentTypeCheckCompletionCallback : public TypeCheckCompletionCallback {
|
|
struct Result {
|
|
/// The type associated with the code completion expression itself.
|
|
Type ExpectedType;
|
|
|
|
/// The expected return type of the function call.
|
|
Type ExpectedCallType;
|
|
|
|
/// True if this is a subscript rather than a function call.
|
|
bool IsSubscript;
|
|
|
|
/// The FuncDecl or SubscriptDecl associated with the call.
|
|
ValueDecl *FuncD;
|
|
|
|
/// The type of the function being called.
|
|
AnyFunctionType *FuncTy;
|
|
|
|
/// The index of the argument containing the completion location
|
|
unsigned ArgIdx;
|
|
|
|
/// The index of the parameter corresponding to the completion argument.
|
|
std::optional<unsigned> ParamIdx;
|
|
|
|
/// The indices of all params that were bound to non-synthesized
|
|
/// arguments. Used so we don't suggest them even when the args are out of
|
|
/// order.
|
|
std::set<unsigned> ClaimedParamIndices;
|
|
|
|
/// True if the completion is a noninitial term in a variadic argument.
|
|
bool IsNoninitialVariadic;
|
|
|
|
/// Whether to suggest the entire functions signature instead of a single
|
|
/// argument for this result.
|
|
///
|
|
/// This is the case if there are no arguments or labels in the call yet and
|
|
/// causes us to add a completion result that completes `Point(|)` to
|
|
/// `Point(x: <Int>, y: <Int>)`.
|
|
bool IncludeSignature;
|
|
|
|
/// The base type of the call/subscript (null for free functions).
|
|
Type BaseType;
|
|
|
|
/// True if an argument label precedes the completion location.
|
|
bool HasLabel;
|
|
|
|
/// The argument index of the first trailing closure.
|
|
///
|
|
/// \c None if the call doesn't have a trailing closure.
|
|
std::optional<unsigned> FirstTrailingClosureIndex;
|
|
|
|
/// Whether the surrounding context is async and thus calling async
|
|
/// functions is supported.
|
|
bool IsInAsyncContext;
|
|
|
|
/// True if the function is an implicitly curried instance method.
|
|
bool IsImplicitlyCurried;
|
|
|
|
/// True if the call is the second apply of a double-applied function.
|
|
bool IsSecondApply;
|
|
|
|
/// A bitfield to mark whether the parameter at a given index is optional.
|
|
/// Parameters can be optional if they have a default argument or belong to
|
|
/// a parameter pack.
|
|
/// Indices are based on the parameters in \c FuncTy. Note that the number
|
|
/// of parameters in \c FuncTy and \c FuncD is different when a parameter
|
|
/// pack has been exploded.
|
|
llvm::BitVector DeclParamIsOptional;
|
|
|
|
/// Types of variables that were determined in the solution that produced
|
|
/// this result. This in particular includes parameters of closures that
|
|
/// were type-checked with the code completion expression.
|
|
llvm::SmallDenseMap<const VarDecl *, Type> SolutionSpecificVarTypes;
|
|
};
|
|
|
|
CodeCompletionExpr *CompletionExpr;
|
|
DeclContext *DC;
|
|
|
|
SmallVector<Result, 4> Results;
|
|
|
|
/// Populates a vector of parameters to suggest along with a vector of types
|
|
/// to match the lookup results against.
|
|
///
|
|
/// \Returns true if global lookup should be performed.
|
|
bool addPossibleParams(const ArgumentTypeCheckCompletionCallback::Result &Res,
|
|
SmallVectorImpl<PossibleParamInfo> &Params,
|
|
SmallVectorImpl<Type> &Types);
|
|
|
|
void sawSolutionImpl(const constraints::Solution &solution) override;
|
|
|
|
/// Populates \p ShadowedDecls with all \c FuncD in \p Results that are
|
|
/// defined in protocol extensions but redeclared on a nominal type and thus
|
|
/// cannot be accessed
|
|
void computeShadowedDecls(SmallPtrSetImpl<ValueDecl *> &ShadowedDecls);
|
|
|
|
public:
|
|
ArgumentTypeCheckCompletionCallback(CodeCompletionExpr *CompletionExpr,
|
|
DeclContext *DC)
|
|
: CompletionExpr(CompletionExpr), DC(DC) {}
|
|
|
|
/// \param IsLabeledTrailingClosure Whether we are completing the label of a
|
|
/// labeled trailing closure, ie. if the code completion location is outside
|
|
/// the call after the first trailing closure of the call.
|
|
void collectResults(bool IsLabeledTrailingClosure, SourceLoc Loc,
|
|
DeclContext *DC, CodeCompletionContext &CompletionCtx);
|
|
|
|
/// Collects non-shadowed signature results into \p Signatures
|
|
void getSignatures(SourceLoc Loc, DeclContext *DC,
|
|
SmallVectorImpl<Signature> &Signatures);
|
|
};
|
|
|
|
} // end namespace ide
|
|
} // end namespace swift
|
|
|
|
#endif // SWIFT_IDE_ARGUMENTCOMPLETION_H
|