Introduce callables.

Introduce callables: values that can be "called" like functions.
Add a new `call` declaration kind to represent callable methods.

Author: dan-zheng

include/swift/AST/Decl.h

@@ -54,6 +54,7 @@ namespace swift {
   struct ASTNode;
   class ASTPrinter;
   class ASTWalker;
+  class CallDecl;
   class ConstructorDecl;
   class DestructorDecl;
   class DiagnosticEngine;
@@ -137,6 +138,7 @@ enum class DescriptiveDeclKind : uint8_t {
   GenericStruct,
   GenericClass,
   GenericType,
+  Call,
   Subscript,
   Constructor,
   Destructor,
@@ -3296,6 +3298,21 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
                              ToStoredPropertyOrMissingMemberPlaceholder());
   }
 
+private:
+  /// Predicate used to filter CallDeclRange.
+  struct ToCallDecl {
+    ToCallDecl() {}
+    Optional<CallDecl *> operator()(Decl *decl) const;
+  };
+
+public:
+  /// A range for iterating the call declarations of a nominal type.
+  using CallDeclRange = OptionalTransformRange<DeclRange,
+                                               ToCallDecl>;
+
+  /// Return a collection of the call declarations of this nominal type.
+  CallDeclRange getCallDeclarations() const;
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_NominalTypeDecl &&
@@ -5732,7 +5749,8 @@ class FuncDecl : public AbstractFunctionDecl {
 
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::Func ||
-           D->getKind() == DeclKind::Accessor;
+           D->getKind() == DeclKind::Accessor ||
+           D->getKind() == DeclKind::Call;
   }
   static bool classof(const AbstractFunctionDecl *D) {
     return classof(static_cast<const Decl*>(D));
@@ -5885,7 +5903,53 @@ AbstractStorageDecl::AccessorRecord::getAccessor(AccessorKind kind) const {
   }
   return nullptr;
 }
-  
+
+/// CallDecl - Declares a callable method for a type. For example:
+///
+/// \code
+/// struct Adder {
+///   var base: Int
+///   call(_ x: Int) -> Int {
+///      return base + x
+///   }
+/// }
+/// \endcode
+class CallDecl final : public FuncDecl {
+  CallDecl(DeclName fullName, SourceLoc declLoc, bool throws,
+           SourceLoc throwsLoc, unsigned numParameterLists,
+           GenericParamList *genericParams, DeclContext *parent)
+    : FuncDecl(DeclKind::Call,
+               /*staticLoc*/ SourceLoc(), StaticSpellingKind::None,
+               /*func loc*/ declLoc, /*name*/ fullName, /*name loc*/ declLoc,
+               throws, throwsLoc, numParameterLists, genericParams, parent) {}
+
+  static CallDecl *createImpl(ASTContext &ctx, DeclName fullName,
+                              SourceLoc declLoc, bool throws,
+                              SourceLoc throwsLoc,
+                              GenericParamList *genericParams,
+                              DeclContext *parent, ClangNode clangNode);
+
+public:
+  static CallDecl *create(ASTContext &ctx, DeclName fullName, SourceLoc declLoc,
+                          bool throws, SourceLoc throwsLoc,
+                          GenericParamList *genericParams,
+                          ParameterList *parameterList,
+                          TypeLoc fnRetType, DeclContext *parent,
+                          ClangNode clangNode = ClangNode());
+
+  static bool classof(const Decl *D) {
+    return D->getKind() == DeclKind::Call;
+  }
+  static bool classof(const AbstractFunctionDecl *D) {
+    return classof(static_cast<const Decl*>(D));
+  }
+  static bool classof(const DeclContext *DC) {
+    if (auto D = DC->getAsDecl())
+      return classof(D);
+    return false;
+  }
+};
+
 /// This represents a 'case' declaration in an 'enum', which may declare
 /// one or more individual comma-separated EnumElementDecls.
 class EnumCaseDecl final : public Decl,
@@ -6775,6 +6839,13 @@ ::operator()(Decl *decl) const {
   return None;
 }
 
+inline Optional<CallDecl *>
+NominalTypeDecl::ToCallDecl::operator()(Decl *decl) const {
+  if (auto callDecl = dyn_cast<CallDecl>(decl))
+    return callDecl;
+  return None;
+}
+
 inline void
 AbstractStorageDecl::overwriteSetterAccess(AccessLevel accessLevel) {
   Accessors.setInt(accessLevel);
@@ -6808,6 +6879,7 @@ inline ParamDecl **AbstractFunctionDecl::getImplicitSelfDeclStorage() {
     return cast<DestructorDecl>(this)->getImplicitSelfDeclStorage();
   case DeclKind::Func:
   case DeclKind::Accessor:
+  case DeclKind::Call:
     return cast<FuncDecl>(this)->getImplicitSelfDeclStorage();
   }
 }
@@ -6816,11 +6888,12 @@ inline ParamDecl **FuncDecl::getImplicitSelfDeclStorage() {
   if (!hasImplicitSelfDecl())
     return nullptr;
 
-  if (!isa<AccessorDecl>(this)) {
-    assert(getKind() == DeclKind::Func && "no new kinds of functions");
-    return reinterpret_cast<ParamDecl **>(this+1);
-  }
-  return reinterpret_cast<ParamDecl **>(static_cast<AccessorDecl*>(this)+1);
+  if (isa<AccessorDecl>(this))
+    return reinterpret_cast<ParamDecl **>(static_cast<AccessorDecl *>(this)+1);
+  else if (isa<CallDecl>(this))
+    return reinterpret_cast<ParamDecl **>(static_cast<CallDecl *>(this)+1);
+  assert(getKind() == DeclKind::Func && "no new kinds of functions");
+  return reinterpret_cast<ParamDecl **>(this+1);
 }
 
 inline DeclIterator &DeclIterator::operator++() {

include/swift/AST/DeclNodes.def

@@ -170,7 +170,8 @@ ABSTRACT_DECL(Value, Decl)
     ABSTRACT_FUNCTION_DECL(Destructor, AbstractFunctionDecl)
     ABSTRACT_FUNCTION_DECL(Func, AbstractFunctionDecl)
       ABSTRACT_FUNCTION_DECL(Accessor, FuncDecl)
-    DECL_RANGE(AbstractFunction, Constructor, Accessor)
+      ABSTRACT_FUNCTION_DECL(Call, FuncDecl)
+    DECL_RANGE(AbstractFunction, Constructor, Call)
   CONTEXT_VALUE_DECL(EnumElement, ValueDecl)
   DECL_RANGE(Value, Enum, EnumElement)
 

include/swift/AST/DiagnosticsParse.def

@@ -395,6 +395,16 @@ ERROR(subscript_without_get,none,
 ERROR(subscript_static,none,
       "subscript cannot be marked %0", (StaticSpellingKind))
 
+// `call` member
+ERROR(call_decl_static,none,
+      "'call' member cannot be marked %0", (StaticSpellingKind))
+ERROR(call_decl_wrong_scope,none,
+      "'call' members may only be declared within a type", ())
+ERROR(expected_lparen_call,PointsToFirstBadToken,
+      "expected '(' for 'call' member parameters", ())
+ERROR(call_decl_cannot_have_name,PointsToFirstBadToken,
+      "'call' member cannot have a name", ())
+
 // initializer
 ERROR(invalid_nested_init,none,
       "missing '%select{super.|self.}0' at initializer invocation", (bool))

include/swift/AST/DiagnosticsSema.def

@@ -1051,6 +1051,9 @@ NOTE(archetype_declared_in_type,none,
 NOTE(unbound_generic_parameter_explicit_fix,none,
      "explicitly specify the generic arguments to fix this issue", ())
 
+ERROR(missing_call_decl,none,
+      "%0 does not define 'call' declaration of type", (Type))
+
 ERROR(invalid_dynamic_callable_type,none,
       "@dynamicCallable attribute requires %0 to have either a valid "
       "'dynamicallyCall(withArguments:)' method or "
@@ -1765,8 +1768,8 @@ NOTE(inherited_protocol_does_not_conform,none,
      "type %0 does not conform to inherited protocol %1", (Type, Type))
 NOTE(no_witnesses,none,
      "protocol requires "
-     "%select{initializer %1|function %1|property %1|subscript}0 with type %2"
-     "%select{|; do you want to add a stub?}3",
+     "%select{initializer %1|function %1|property %1|subscript|'call' member}0 "
+     "with type %2%select{|; do you want to add a stub?}3",
      (RequirementKind, DeclName, Type, bool))
 NOTE(missing_witnesses_general,none, "do you want to add protocol stubs?",
      ())

include/swift/AST/DiagnosticsSema.h

@@ -29,7 +29,8 @@ namespace swift {
       Constructor,
       Func,
       Var,
-      Subscript
+      Subscript,
+      Call
     };
 
   // Declare common diagnostics objects with their appropriate types.

include/swift/AST/Identifier.h

@@ -221,8 +221,8 @@ class DeclBaseName {
   };
 
 private:
-  /// In a special DeclName represenenting a subscript, this opaque pointer
-  /// is used as the data of the base name identifier.
+  /// In a special DeclName representing a subscript, this opaque pointer is
+  /// used as the data of the base name identifier.
   /// This is an implementation detail that should never leak outside of
   /// DeclName.
   static void *SubscriptIdentifierData;

include/swift/Demangling/DemangleNodes.def

@@ -43,6 +43,7 @@ NODE(BoundGenericOtherNominalType)
 NODE(BoundGenericTypeAlias)
 NODE(BoundGenericFunction)
 NODE(BuiltinTypeName)
+CONTEXT_NODE(CallDeclaration)
 NODE(CFunctionPointer)
 CONTEXT_NODE(Class)
 NODE(ClassMetadataBaseOffset)

include/swift/IDE/CodeCompletion.h

@@ -398,6 +398,7 @@ enum class CodeCompletionDeclKind {
   Constructor,
   Destructor,
   Subscript,
+  Call,
   StaticMethod,
   InstanceMethod,
   PrefixOperatorFunction,

include/swift/IDE/SyntaxModel.h

@@ -97,6 +97,7 @@ enum class SyntaxStructureKind : uint8_t {
   EnumElement,
   TypeAlias,
   Subscript,
+  Call,
   AssociatedType,
   GenericTypeParam,
 

include/swift/Parse/Parser.h

@@ -520,7 +520,8 @@ class Parser {
   }
 
   SourceLoc consumeIdentifier(Identifier *Result = nullptr) {
-    assert(Tok.isAny(tok::identifier, tok::kw_self, tok::kw_Self));
+    assert(Tok.isAny(tok::identifier, tok::kw_self, tok::kw_Self,
+                     tok::kw_call));
     if (Result)
       *Result = Context.getIdentifier(Tok.getText());
     return consumeToken();
@@ -1005,6 +1006,8 @@ class Parser {
   ParserResult<ProtocolDecl> parseDeclProtocol(ParseDeclOptions Flags,
                                                DeclAttributes &Attributes);
 
+  ParserResult<CallDecl>
+  parseDeclCall(ParseDeclOptions Flags, DeclAttributes &Attributes);
   ParserResult<SubscriptDecl>
   parseDeclSubscript(ParseDeclOptions Flags, DeclAttributes &Attributes,
                      SmallVectorImpl<Decl *> &Decls);
@@ -1160,6 +1163,8 @@ class Parser {
     Closure,
     /// A subscript.
     Subscript,
+    /// A call declaration.
+    Call,
     /// A curried argument clause.
     Curried,
     /// An enum element.
@@ -1198,6 +1203,7 @@ class Parser {
                                       DefaultArgumentInfo &defaultArgs);
   ParserStatus parseFunctionSignature(Identifier functionName,
                                       DeclName &fullName,
+                                      ParameterContextKind paramContext,
                                       ParameterList *&bodyParams,
                                       DefaultArgumentInfo &defaultArgs,
                                       SourceLoc &throws,