[torque] simplify AST around generics

Bug: v8:7793
Change-Id: I5f5461e4e3d31c6d3c2c1fba4ce48a4eb5db5d8e
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1725625
Commit-Queue: Tobias Tebbi <tebbi@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Cr-Commit-Position: refs/heads/master@{#63098}

src/builtins/array-join.tq

@@ -16,7 +16,7 @@ namespace array_join {
     return GetProperty(receiver, k);
   }
 
-  LoadJoinElement<array::DictionaryElements>(
+  transitioning LoadJoinElement<array::DictionaryElements>(
       context: Context, receiver: JSReceiver, k: Number): Object {
     const array: JSArray = UnsafeCast<JSArray>(receiver);
     const dict: NumberDictionary = UnsafeCast<NumberDictionary>(array.elements);
@@ -323,7 +323,7 @@ namespace array_join {
       useToLocaleString: constexpr bool, receiver: JSReceiver, sep: String,
       lenNumber: Number, locales: Object, options: Object): Object;
 
-  ArrayJoin<JSArray>(implicit context: Context)(
+  transitioning ArrayJoin<JSArray>(implicit context: Context)(
       useToLocaleString: constexpr bool, receiver: JSReceiver, sep: String,
       lenNumber: Number, locales: Object, options: Object): Object {
     const map: Map = receiver.map;
@@ -370,7 +370,7 @@ namespace array_join {
         receiver, sep, lenNumber, useToLocaleString, locales, options, loadFn);
   }
 
-  ArrayJoin<JSTypedArray>(implicit context: Context)(
+  transitioning ArrayJoin<JSTypedArray>(implicit context: Context)(
       useToLocaleString: constexpr bool, receiver: JSReceiver, sep: String,
       lenNumber: Number, locales: Object, options: Object): Object {
     const map: Map = receiver.map;

src/torque/ast.h

@@ -71,20 +71,17 @@ namespace torque {
 
 #define AST_DECLARATION_NODE_KIND_LIST(V) \
   AST_TYPE_DECLARATION_NODE_KIND_LIST(V)  \
-  V(StandardDeclaration)                  \
   V(GenericDeclaration)                   \
   V(SpecializationDeclaration)            \
   V(ExternConstDeclaration)               \
   V(NamespaceDeclaration)                 \
   V(ConstDeclaration)                     \
-  V(CppIncludeDeclaration)
-
-#define AST_CALLABLE_NODE_KIND_LIST(V) \
-  V(TorqueMacroDeclaration)            \
-  V(TorqueBuiltinDeclaration)          \
-  V(ExternalMacroDeclaration)          \
-  V(ExternalBuiltinDeclaration)        \
-  V(ExternalRuntimeDeclaration)        \
+  V(CppIncludeDeclaration)                \
+  V(TorqueMacroDeclaration)               \
+  V(TorqueBuiltinDeclaration)             \
+  V(ExternalMacroDeclaration)             \
+  V(ExternalBuiltinDeclaration)           \
+  V(ExternalRuntimeDeclaration)           \
   V(IntrinsicDeclaration)
 
 #define AST_NODE_KIND_LIST(V)           \
@@ -92,7 +89,6 @@ namespace torque {
   AST_TYPE_EXPRESSION_NODE_KIND_LIST(V) \
   AST_STATEMENT_NODE_KIND_LIST(V)       \
   AST_DECLARATION_NODE_KIND_LIST(V)     \
-  AST_CALLABLE_NODE_KIND_LIST(V)        \
   V(Identifier)                         \
   V(LabelBlock)
 
@@ -117,16 +113,16 @@ struct AstNodeClassCheck {
 };
 
 // Boilerplate for most derived classes.
-#define DEFINE_AST_NODE_LEAF_BOILERPLATE(T)                        \
-  static const Kind kKind = Kind::k##T;                            \
-  static T* cast(AstNode* node) {                                  \
-    if (node->kind != kKind) return nullptr;                       \
-    return static_cast<T*>(node);                                  \
-  }                                                                \
-  static T* DynamicCast(AstNode* node) {                           \
-    if (!node) return nullptr;                                     \
-    if (!AstNodeClassCheck::IsInstanceOf<T>(node)) return nullptr; \
-    return static_cast<T*>(node);                                  \
+#define DEFINE_AST_NODE_LEAF_BOILERPLATE(T)  \
+  static const Kind kKind = Kind::k##T;      \
+  static T* cast(AstNode* node) {            \
+    DCHECK_EQ(node->kind, kKind);            \
+    return static_cast<T*>(node);            \
+  }                                          \
+  static T* DynamicCast(AstNode* node) {     \
+    if (!node) return nullptr;               \
+    if (node->kind != kKind) return nullptr; \
+    return static_cast<T*>(node);            \
   }
 
 // Boilerplate for classes with subclasses.
@@ -220,6 +216,10 @@ struct Identifier : AstNode {
   std::string value;
 };
 
+inline std::ostream& operator<<(std::ostream& os, Identifier* id) {
+  return os << id->value;
+}
+
 struct IdentifierPtrValueEq {
   bool operator()(const Identifier* a, const Identifier* b) {
     return a->value < b->value;
@@ -251,11 +251,11 @@ struct IdentifierExpression : LocationExpression {
 
 struct IntrinsicCallExpression : Expression {
   DEFINE_AST_NODE_LEAF_BOILERPLATE(IntrinsicCallExpression)
-  IntrinsicCallExpression(SourcePosition pos, std::string name,
+  IntrinsicCallExpression(SourcePosition pos, Identifier* name,
                           std::vector<TypeExpression*> generic_arguments,
                           std::vector<Expression*> arguments)
       : Expression(kKind, pos),
-        name(std::move(name)),
+        name(name),
         generic_arguments(std::move(generic_arguments)),
         arguments(std::move(arguments)) {}
 
@@ -266,7 +266,7 @@ struct IntrinsicCallExpression : Expression {
     callback(this);
   }
 
-  std::string name;
+  Identifier* name;
   std::vector<TypeExpression*> generic_arguments;
   std::vector<Expression*> arguments;
 };
@@ -857,34 +857,33 @@ struct LabelAndTypes {
 
 using LabelAndTypesVector = std::vector<LabelAndTypes>;
 
-struct CallableNodeSignature {
+struct CallableDeclaration : Declaration {
+  CallableDeclaration(AstNode::Kind kind, SourcePosition pos,
+                      bool transitioning, Identifier* name,
+                      ParameterList parameters, TypeExpression* return_type,
+                      LabelAndTypesVector labels)
+      : Declaration(kind, pos),
+        transitioning(transitioning),
+        name(name),
+        parameters(std::move(parameters)),
+        return_type(return_type),
+        labels(std::move(labels)) {}
+  DEFINE_AST_NODE_INNER_BOILERPLATE(CallableDeclaration)
+  bool transitioning;
+  Identifier* name;
   ParameterList parameters;
   TypeExpression* return_type;
   LabelAndTypesVector labels;
 };
 
-struct CallableNode : AstNode {
-  CallableNode(AstNode::Kind kind, SourcePosition pos, bool transitioning,
-               std::string name, ParameterList parameters,
-               TypeExpression* return_type, const LabelAndTypesVector& labels)
-      : AstNode(kind, pos),
-        transitioning(transitioning),
-        name(std::move(name)),
-        signature(new CallableNodeSignature{parameters, return_type, labels}) {}
-  DEFINE_AST_NODE_INNER_BOILERPLATE(CallableNode)
-  bool transitioning;
-  std::string name;
-  std::unique_ptr<CallableNodeSignature> signature;
-};
-
-struct MacroDeclaration : CallableNode {
+struct MacroDeclaration : CallableDeclaration {
   DEFINE_AST_NODE_INNER_BOILERPLATE(MacroDeclaration)
   MacroDeclaration(AstNode::Kind kind, SourcePosition pos, bool transitioning,
-                   std::string name, base::Optional<std::string> op,
+                   Identifier* name, base::Optional<std::string> op,
                    ParameterList parameters, TypeExpression* return_type,
                    const LabelAndTypesVector& labels)
-      : CallableNode(kind, pos, transitioning, std::move(name),
-                     std::move(parameters), return_type, labels),
+      : CallableDeclaration(kind, pos, transitioning, name,
+                            std::move(parameters), return_type, labels),
         op(std::move(op)) {
     if (parameters.implicit_kind == ImplicitKind::kJSImplicit) {
       Error("Cannot use \"js-implicit\" with macros, use \"implicit\" instead.")
@@ -898,23 +897,22 @@ struct ExternalMacroDeclaration : MacroDeclaration {
   DEFINE_AST_NODE_LEAF_BOILERPLATE(ExternalMacroDeclaration)
   ExternalMacroDeclaration(SourcePosition pos, bool transitioning,
                            std::string external_assembler_name,
-                           std::string name, base::Optional<std::string> op,
+                           Identifier* name, base::Optional<std::string> op,
                            ParameterList parameters,
                            TypeExpression* return_type,
                            const LabelAndTypesVector& labels)
-      : MacroDeclaration(kKind, pos, transitioning, std::move(name),
-                         std::move(op), std::move(parameters), return_type,
-                         labels),
+      : MacroDeclaration(kKind, pos, transitioning, name, std::move(op),
+                         std::move(parameters), return_type, labels),
         external_assembler_name(std::move(external_assembler_name)) {}
   std::string external_assembler_name;
 };
 
-struct IntrinsicDeclaration : CallableNode {
+struct IntrinsicDeclaration : CallableDeclaration {
   DEFINE_AST_NODE_LEAF_BOILERPLATE(IntrinsicDeclaration)
-  IntrinsicDeclaration(SourcePosition pos, std::string name,
+  IntrinsicDeclaration(SourcePosition pos, Identifier* name,
                        ParameterList parameters, TypeExpression* return_type)
-      : CallableNode(kKind, pos, false, std::move(name), std::move(parameters),
-                     return_type, {}) {
+      : CallableDeclaration(kKind, pos, false, name, std::move(parameters),
+                            return_type, {}) {
     if (parameters.implicit_kind != ImplicitKind::kNoImplicit) {
       Error("Intinsics cannot have implicit parameters.");
     }
@@ -924,24 +922,26 @@ struct IntrinsicDeclaration : CallableNode {
 struct TorqueMacroDeclaration : MacroDeclaration {
   DEFINE_AST_NODE_LEAF_BOILERPLATE(TorqueMacroDeclaration)
   TorqueMacroDeclaration(SourcePosition pos, bool transitioning,
-                         std::string name, base::Optional<std::string> op,
+                         Identifier* name, base::Optional<std::string> op,
                          ParameterList parameters, TypeExpression* return_type,
-                         const LabelAndTypesVector& labels, bool export_to_csa)
-      : MacroDeclaration(kKind, pos, transitioning, std::move(name),
-                         std::move(op), std::move(parameters), return_type,
-                         labels),
-        export_to_csa(export_to_csa) {}
+                         const LabelAndTypesVector& labels, bool export_to_csa,
+                         base::Optional<Statement*> body)
+      : MacroDeclaration(kKind, pos, transitioning, name, std::move(op),
+                         std::move(parameters), return_type, labels),
+        export_to_csa(export_to_csa),
+        body(body) {}
   bool export_to_csa;
+  base::Optional<Statement*> body;
 };
 
-struct BuiltinDeclaration : CallableNode {
+struct BuiltinDeclaration : CallableDeclaration {
   DEFINE_AST_NODE_INNER_BOILERPLATE(BuiltinDeclaration)
   BuiltinDeclaration(AstNode::Kind kind, SourcePosition pos,
                      bool javascript_linkage, bool transitioning,
-                     std::string name, ParameterList parameters,
+                     Identifier* name, ParameterList parameters,
                      TypeExpression* return_type)
-      : CallableNode(kind, pos, transitioning, std::move(name),
-                     std::move(parameters), return_type, {}),
+      : CallableDeclaration(kind, pos, transitioning, name,
+                            std::move(parameters), return_type, {}),
         javascript_linkage(javascript_linkage) {
     if (parameters.implicit_kind == ImplicitKind::kJSImplicit &&
         !javascript_linkage) {
@@ -963,32 +963,33 @@ struct BuiltinDeclaration : CallableNode {
 struct ExternalBuiltinDeclaration : BuiltinDeclaration {
   DEFINE_AST_NODE_LEAF_BOILERPLATE(ExternalBuiltinDeclaration)
   ExternalBuiltinDeclaration(SourcePosition pos, bool transitioning,
-                             bool javascript_linkage, std::string name,
+                             bool javascript_linkage, Identifier* name,
                              ParameterList parameters,
                              TypeExpression* return_type)
-      : BuiltinDeclaration(kKind, pos, javascript_linkage, transitioning,
-                           std::move(name), std::move(parameters),
-                           return_type) {}
+      : BuiltinDeclaration(kKind, pos, javascript_linkage, transitioning, name,
+                           std::move(parameters), return_type) {}
 };
 
 struct TorqueBuiltinDeclaration : BuiltinDeclaration {
   DEFINE_AST_NODE_LEAF_BOILERPLATE(TorqueBuiltinDeclaration)
   TorqueBuiltinDeclaration(SourcePosition pos, bool transitioning,
-                           bool javascript_linkage, std::string name,
+                           bool javascript_linkage, Identifier* name,
                            ParameterList parameters,
-                           TypeExpression* return_type)
-      : BuiltinDeclaration(kKind, pos, javascript_linkage, transitioning,
-                           std::move(name), std::move(parameters),
-                           return_type) {}
+                           TypeExpression* return_type,
+                           base::Optional<Statement*> body)
+      : BuiltinDeclaration(kKind, pos, javascript_linkage, transitioning, name,
+                           std::move(parameters), return_type),
+        body(body) {}
+  base::Optional<Statement*> body;
 };
 
-struct ExternalRuntimeDeclaration : CallableNode {
+struct ExternalRuntimeDeclaration : CallableDeclaration {
   DEFINE_AST_NODE_LEAF_BOILERPLATE(ExternalRuntimeDeclaration)
   ExternalRuntimeDeclaration(SourcePosition pos, bool transitioning,
-                             std::string name, ParameterList parameters,
+                             Identifier* name, ParameterList parameters,
                              TypeExpression* return_type)
-      : CallableNode(kKind, pos, transitioning, name, parameters, return_type,
-                     {}) {}
+      : CallableDeclaration(kKind, pos, transitioning, name, parameters,
+                            return_type, {}) {}
 };
 
 struct ConstDeclaration : Declaration {
@@ -1004,47 +1005,32 @@ struct ConstDeclaration : Declaration {
   Expression* expression;
 };
 
-struct StandardDeclaration : Declaration {
-  DEFINE_AST_NODE_LEAF_BOILERPLATE(StandardDeclaration)
-  StandardDeclaration(SourcePosition pos, CallableNode* callable,
-                      base::Optional<Statement*> body)
-      : Declaration(kKind, pos), callable(callable), body(body) {}
-  CallableNode* callable;
-  base::Optional<Statement*> body;
-};
-
 struct GenericDeclaration : Declaration {
   DEFINE_AST_NODE_LEAF_BOILERPLATE(GenericDeclaration)
-  GenericDeclaration(SourcePosition pos, CallableNode* callable,
+  GenericDeclaration(SourcePosition pos,
                      std::vector<Identifier*> generic_parameters,
-                     base::Optional<Statement*> body = base::nullopt)
+                     CallableDeclaration* declaration)
       : Declaration(kKind, pos),
-        callable(callable),
         generic_parameters(std::move(generic_parameters)),
-        body(body) {}
-  CallableNode* callable;
+        declaration(declaration) {}
   std::vector<Identifier*> generic_parameters;
-  base::Optional<Statement*> body;
+  CallableDeclaration* declaration;
 };
 
-struct SpecializationDeclaration : Declaration {
+struct SpecializationDeclaration : CallableDeclaration {
   DEFINE_AST_NODE_LEAF_BOILERPLATE(SpecializationDeclaration)
-  SpecializationDeclaration(SourcePosition pos, Identifier* name,
+  SpecializationDeclaration(SourcePosition pos, bool transitioning,
+                            Identifier* name,
                             std::vector<TypeExpression*> generic_parameters,
                             ParameterList parameters,
                             TypeExpression* return_type,
-                            LabelAndTypesVector labels, Statement* b)
-      : Declaration(kKind, pos),
-        name(name),
-        external(false),
+                            LabelAndTypesVector labels, Statement* body)
+      : CallableDeclaration(kKind, pos, transitioning, name,
+                            std::move(parameters), return_type,
+                            std::move(labels)),
         generic_parameters(std::move(generic_parameters)),
-        signature(new CallableNodeSignature{std::move(parameters), return_type,
-                                            std::move(labels)}),
-        body(b) {}
-  Identifier* name;
-  bool external;
+        body(body) {}
   std::vector<TypeExpression*> generic_parameters;
-  std::unique_ptr<CallableNodeSignature> signature;
   Statement* body;
 };
 

src/torque/declarable.cc

@@ -59,7 +59,7 @@ std::ostream& operator<<(std::ostream& os, const RuntimeFunction& b) {
 std::ostream& operator<<(std::ostream& os, const Generic& g) {
   os << "generic " << g.name() << "<";
   PrintCommaSeparatedList(
-      os, g.declaration()->generic_parameters,
+      os, g.generic_parameters(),
       [](const Identifier* identifier) { return identifier->value; });
   os << ">";
 
@@ -69,19 +69,29 @@ std::ostream& operator<<(std::ostream& os, const Generic& g) {
 TypeArgumentInference Generic::InferSpecializationTypes(
     const TypeVector& explicit_specialization_types,
     const TypeVector& arguments) {
-  size_t implicit_count =
-      declaration()->callable->signature->parameters.implicit_count;
+  size_t implicit_count = declaration()->parameters.implicit_count;
   const std::vector<TypeExpression*>& parameters =
-      declaration()->callable->signature->parameters.types;
+      declaration()->parameters.types;
   std::vector<TypeExpression*> explicit_parameters(
       parameters.begin() + implicit_count, parameters.end());
 
-  TypeArgumentInference inference(declaration()->generic_parameters,
+  TypeArgumentInference inference(generic_parameters(),
                                   explicit_specialization_types,
                                   explicit_parameters, arguments);
   return inference;
 }
 
+base::Optional<Statement*> Generic::CallableBody() {
+  if (auto* decl = TorqueMacroDeclaration::DynamicCast(declaration())) {
+    return decl->body;
+  } else if (auto* decl =
+                 TorqueBuiltinDeclaration::DynamicCast(declaration())) {
+    return decl->body;
+  } else {
+    return base::nullopt;
+  }
+}
+
 bool Namespace::IsDefaultNamespace() const {
   return this == GlobalContext::GetDefaultNamespace();
 }

src/torque/declarable.h

@@ -262,6 +262,7 @@ class Callable : public Scope {
   const std::string& ExternalName() const { return external_name_; }
   const std::string& ReadableName() const { return readable_name_; }
   const Signature& signature() const { return signature_; }
+  bool IsTransitioning() const { return signature().transitioning; }
   const NameVector& parameter_names() const {
     return signature_.parameter_names;
   }
@@ -270,7 +271,6 @@ class Callable : public Scope {
   }
   void IncrementReturns() { ++returns_; }
   bool HasReturns() const { return returns_; }
-  bool IsTransitioning() const { return transitioning_; }
   base::Optional<Statement*> body() const { return body_; }
   bool IsExternal() const { return !body_.has_value(); }
   virtual bool ShouldBeInlined() const { return false; }
@@ -278,14 +278,13 @@ class Callable : public Scope {
 
  protected:
   Callable(Declarable::Kind kind, std::string external_name,
-           std::string readable_name, Signature signature, bool transitioning,
+           std::string readable_name, Signature signature,
            base::Optional<Statement*> body)
       : Scope(kind),
         external_name_(std::move(external_name)),
 
         readable_name_(std::move(readable_name)),
         signature_(std::move(signature)),
-        transitioning_(transitioning),
         returns_(0),
         body_(body) {
     DCHECK(!body || *body);
@@ -295,7 +294,6 @@ class Callable : public Scope {
   std::string external_name_;
   std::string readable_name_;
   Signature signature_;
-  bool transitioning_;
   size_t returns_;
   base::Optional<Statement*> body_;
 };
@@ -321,9 +319,9 @@ class Macro : public Callable {
  protected:
   Macro(Declarable::Kind kind, std::string external_name,
         std::string readable_name, const Signature& signature,
-        bool transitioning, base::Optional<Statement*> body)
+        base::Optional<Statement*> body)
       : Callable(kind, std::move(external_name), std::move(readable_name),
-                 signature, transitioning, body),
+                 signature, body),
         used_(false) {
     if (signature.parameter_types.var_args) {
       ReportError("Varargs are not supported for macros.");
@@ -345,9 +343,9 @@ class ExternMacro : public Macro {
  private:
   friend class Declarations;
   ExternMacro(const std::string& name, std::string external_assembler_name,
-              Signature signature, bool transitioning)
+              Signature signature)
       : Macro(Declarable::kExternMacro, name, name, std::move(signature),
-              transitioning, base::nullopt),
+              base::nullopt),
         external_assembler_name_(std::move(external_assembler_name)) {}
 
   std::string external_assembler_name_;
@@ -361,10 +359,10 @@ class TorqueMacro : public Macro {
  protected:
   TorqueMacro(Declarable::Kind kind, std::string external_name,
               std::string readable_name, const Signature& signature,
-              bool transitioning, base::Optional<Statement*> body,
-              bool is_user_defined, bool exported_to_csa)
+              base::Optional<Statement*> body, bool is_user_defined,
+              bool exported_to_csa)
       : Macro(kind, std::move(external_name), std::move(readable_name),
-              signature, transitioning, body),
+              signature, body),
         exported_to_csa_(exported_to_csa) {
     SetIsUserDefined(is_user_defined);
   }
@@ -372,12 +370,11 @@ class TorqueMacro : public Macro {
  private:
   friend class Declarations;
   TorqueMacro(std::string external_name, std::string readable_name,
-              const Signature& signature, bool transitioning,
-              base::Optional<Statement*> body, bool is_user_defined,
-              bool exported_to_csa)
+              const Signature& signature, base::Optional<Statement*> body,
+              bool is_user_defined, bool exported_to_csa)
       : TorqueMacro(Declarable::kTorqueMacro, std::move(external_name),
-                    std::move(readable_name), signature, transitioning, body,
-                    is_user_defined, exported_to_csa) {}
+                    std::move(readable_name), signature, body, is_user_defined,
+                    exported_to_csa) {}
 
   bool exported_to_csa_ = false;
 };
@@ -396,11 +393,9 @@ class Method : public TorqueMacro {
  private:
   friend class Declarations;
   Method(AggregateType* aggregate_type, std::string external_name,
-         std::string readable_name, const Signature& signature,
-         bool transitioning, Statement* body)
+         std::string readable_name, const Signature& signature, Statement* body)
       : TorqueMacro(Declarable::kMethod, std::move(external_name),
-                    std::move(readable_name), signature, transitioning, body,
-                    true, false),
+                    std::move(readable_name), signature, body, true, false),
         aggregate_type_(aggregate_type) {}
   AggregateType* aggregate_type_;
 };
@@ -417,10 +412,10 @@ class Builtin : public Callable {
  private:
   friend class Declarations;
   Builtin(std::string external_name, std::string readable_name,
-          Builtin::Kind kind, const Signature& signature, bool transitioning,
+          Builtin::Kind kind, const Signature& signature,
           base::Optional<Statement*> body)
       : Callable(Declarable::kBuiltin, std::move(external_name),
-                 std::move(readable_name), signature, transitioning, body),
+                 std::move(readable_name), signature, body),
         kind_(kind) {}
 
   Kind kind_;
@@ -432,10 +427,9 @@ class RuntimeFunction : public Callable {
 
  private:
   friend class Declarations;
-  RuntimeFunction(const std::string& name, const Signature& signature,
-                  bool transitioning)
+  RuntimeFunction(const std::string& name, const Signature& signature)
       : Callable(Declarable::kRuntimeFunction, name, name, signature,
-                 transitioning, base::nullopt) {}
+                 base::nullopt) {}
 };
 
 class Intrinsic : public Callable {
@@ -445,8 +439,7 @@ class Intrinsic : public Callable {
  private:
   friend class Declarations;
   Intrinsic(std::string name, const Signature& signature)
-      : Callable(Declarable::kIntrinsic, name, name, signature, false,
-                 base::nullopt) {
+      : Callable(Declarable::kIntrinsic, name, name, signature, base::nullopt) {
     if (signature.parameter_types.var_args) {
       ReportError("Varargs are not supported for intrinsics.");
     }
@@ -484,25 +477,29 @@ class Generic : public Declarable {
   DECLARE_DECLARABLE_BOILERPLATE(Generic, generic)
 
   const std::string& name() const { return name_; }
-  GenericDeclaration* declaration() const { return declaration_; }
+  CallableDeclaration* declaration() const {
+    return generic_declaration_->declaration;
+  }
   const std::vector<Identifier*> generic_parameters() const {
-    return declaration()->generic_parameters;
+    return generic_declaration_->generic_parameters;
   }
   SpecializationMap<Callable>& specializations() { return specializations_; }
 
+  base::Optional<Statement*> CallableBody();
+
   TypeArgumentInference InferSpecializationTypes(
       const TypeVector& explicit_specialization_types,
       const TypeVector& arguments);
 
  private:
   friend class Declarations;
-  Generic(const std::string& name, GenericDeclaration* declaration)
+  Generic(const std::string& name, GenericDeclaration* generic_declaration)
       : Declarable(Declarable::kGeneric),
         name_(name),
-        declaration_(declaration) {}
+        generic_declaration_(generic_declaration) {}
 
   std::string name_;
-  GenericDeclaration* declaration_;
+  GenericDeclaration* generic_declaration_;
   SpecializationMap<Callable> specializations_;
 };
 

src/torque/declaration-visitor.cc

@@ -53,26 +53,13 @@ void DeclarationVisitor::Visit(Declaration* decl) {
   }
 }
 
-void DeclarationVisitor::Visit(CallableNode* decl, const Signature& signature,
-                               base::Optional<Statement*> body) {
-  switch (decl->kind) {
-#define ENUM_ITEM(name)        \
-  case AstNode::Kind::k##name: \
-    return Visit(name::cast(decl), signature, body);
-    AST_CALLABLE_NODE_KIND_LIST(ENUM_ITEM)
-#undef ENUM_ITEM
-    default:
-      UNIMPLEMENTED();
-  }
-}
-
 Builtin* DeclarationVisitor::CreateBuiltin(BuiltinDeclaration* decl,
                                            std::string external_name,
                                            std::string readable_name,
                                            Signature signature,
                                            base::Optional<Statement*> body) {
   const bool javascript = decl->javascript_linkage;
-  const bool varargs = decl->signature->parameters.has_varargs;
+  const bool varargs = decl->parameters.has_varargs;
   Builtin::Kind kind = !javascript ? Builtin::kStub
                                    : varargs ? Builtin::kVarArgsJavaScript
                                              : Builtin::kFixedArgsJavaScript;
@@ -111,14 +98,20 @@ Builtin* DeclarationVisitor::CreateBuiltin(BuiltinDeclaration* decl,
           struct_type->name());
   }
 
-  return Declarations::CreateBuiltin(
-      std::move(external_name), std::move(readable_name), kind,
-      std::move(signature), decl->transitioning, body);
+  return Declarations::CreateBuiltin(std::move(external_name),
+                                     std::move(readable_name), kind,
+                                     std::move(signature), body);
+}
+
+void DeclarationVisitor::Visit(ExternalBuiltinDeclaration* decl) {
+  Declarations::Declare(
+      decl->name->value,
+      CreateBuiltin(decl, decl->name->value, decl->name->value,
+                    TypeVisitor::MakeSignature(decl), base::nullopt));
 }
 
-void DeclarationVisitor::Visit(ExternalRuntimeDeclaration* decl,
-                               const Signature& signature,
-                               base::Optional<Statement*> body) {
+void DeclarationVisitor::Visit(ExternalRuntimeDeclaration* decl) {
+  Signature signature = TypeVisitor::MakeSignature(decl);
   if (signature.parameter_types.types.size() == 0 ||
       !(signature.parameter_types.types[0] == TypeOracle::GetContextType())) {
     ReportError(
@@ -142,39 +135,34 @@ void DeclarationVisitor::Visit(ExternalRuntimeDeclaration* decl,
     }
   }
 
-  Declarations::DeclareRuntimeFunction(decl->name, signature,
-                                       decl->transitioning);
+  Declarations::DeclareRuntimeFunction(decl->name->value, signature);
 }
 
-void DeclarationVisitor::Visit(ExternalMacroDeclaration* decl,
-                               const Signature& signature,
-                               base::Optional<Statement*> body) {
-  Declarations::DeclareMacro(decl->name, true, decl->external_assembler_name,
-                             signature, decl->transitioning, body, decl->op);
+void DeclarationVisitor::Visit(ExternalMacroDeclaration* decl) {
+  Declarations::DeclareMacro(
+      decl->name->value, true, decl->external_assembler_name,
+      TypeVisitor::MakeSignature(decl), base::nullopt, decl->op);
 }
 
-void DeclarationVisitor::Visit(TorqueBuiltinDeclaration* decl,
-                               const Signature& signature,
-                               base::Optional<Statement*> body) {
+void DeclarationVisitor::Visit(TorqueBuiltinDeclaration* decl) {
   Declarations::Declare(
-      decl->name, CreateBuiltin(decl, decl->name, decl->name, signature, body));
+      decl->name->value,
+      CreateBuiltin(decl, decl->name->value, decl->name->value,
+                    TypeVisitor::MakeSignature(decl), decl->body));
 }
 
-void DeclarationVisitor::Visit(TorqueMacroDeclaration* decl,
-                               const Signature& signature,
-                               base::Optional<Statement*> body) {
+void DeclarationVisitor::Visit(TorqueMacroDeclaration* decl) {
   Macro* macro = Declarations::DeclareMacro(
-      decl->name, decl->export_to_csa, base::nullopt, signature,
-      decl->transitioning, body, decl->op);
+      decl->name->value, decl->export_to_csa, base::nullopt,
+      TypeVisitor::MakeSignature(decl), decl->body, decl->op);
   // TODO(szuend): Set identifier_position to decl->name->pos once all callable
   // names are changed from std::string to Identifier*.
   macro->SetPosition(decl->pos);
 }
 
-void DeclarationVisitor::Visit(IntrinsicDeclaration* decl,
-                               const Signature& signature,
-                               base::Optional<Statement*> body) {
-  Declarations::DeclareIntrinsic(decl->name, signature);
+void DeclarationVisitor::Visit(IntrinsicDeclaration* decl) {
+  Declarations::DeclareIntrinsic(decl->name->value,
+                                 TypeVisitor::MakeSignature(decl));
 }
 
 void DeclarationVisitor::Visit(ConstDeclaration* decl) {
@@ -182,27 +170,13 @@ void DeclarationVisitor::Visit(ConstDeclaration* decl) {
       decl->name, TypeVisitor::ComputeType(decl->type), decl->expression);
 }
 
-void DeclarationVisitor::Visit(StandardDeclaration* decl) {
-  Signature signature =
-      TypeVisitor::MakeSignature(decl->callable->signature.get());
-  Visit(decl->callable, signature, decl->body);
-}
-
 void DeclarationVisitor::Visit(SpecializationDeclaration* decl) {
-  if ((decl->body != nullptr) == decl->external) {
-    std::stringstream stream;
-    stream << "specialization of " << decl->name
-           << " must either be marked 'extern' or have a body";
-    ReportError(stream.str());
-  }
-
   std::vector<Generic*> generic_list =
       Declarations::LookupGeneric(decl->name->value);
   // Find the matching generic specialization based on the concrete parameter
   // list.
   Generic* matching_generic = nullptr;
-  Signature signature_with_types =
-      TypeVisitor::MakeSignature(decl->signature.get());
+  Signature signature_with_types = TypeVisitor::MakeSignature(decl);
   for (Generic* generic : generic_list) {
     Signature generic_signature_with_types =
         MakeSpecializedSignature(SpecializationKey<Generic>{
@@ -245,11 +219,12 @@ void DeclarationVisitor::Visit(SpecializationDeclaration* decl) {
                                       matching_generic->IdentifierPosition());
   }
 
+  CallableDeclaration* generic_declaration = matching_generic->declaration();
+
   Specialize(SpecializationKey<Generic>{matching_generic,
                                         TypeVisitor::ComputeTypeVector(
                                             decl->generic_parameters)},
-             matching_generic->declaration()->callable, decl->signature.get(),
-             decl->body, decl->pos);
+             generic_declaration, decl, decl->body, decl->pos);
 }
 
 void DeclarationVisitor::Visit(ExternConstDeclaration* decl) {
@@ -272,7 +247,7 @@ void DeclarationVisitor::DeclareSpecializedTypes(
     const SpecializationKey<Generic>& key) {
   size_t i = 0;
   const std::size_t generic_parameter_count =
-      key.generic->declaration()->generic_parameters.size();
+      key.generic->generic_parameters().size();
   if (generic_parameter_count != key.specialized_types.size()) {
     std::stringstream stream;
     stream << "Wrong generic argument count for specialization of \""
@@ -282,8 +257,7 @@ void DeclarationVisitor::DeclareSpecializedTypes(
   }
 
   for (auto type : key.specialized_types) {
-    Identifier* generic_type_name =
-        key.generic->declaration()->generic_parameters[i++];
+    Identifier* generic_type_name = key.generic->generic_parameters()[i++];
     TypeAlias* alias = Declarations::DeclareType(generic_type_name, type);
     alias->SetIsUserDefined(false);
   }
@@ -297,23 +271,21 @@ Signature DeclarationVisitor::MakeSpecializedSignature(
   Namespace tmp_namespace("_tmp");
   CurrentScope::Scope tmp_namespace_scope(&tmp_namespace);
   DeclareSpecializedTypes(key);
-  return TypeVisitor::MakeSignature(
-      key.generic->declaration()->callable->signature.get());
+  return TypeVisitor::MakeSignature(key.generic->declaration());
 }
 
 Callable* DeclarationVisitor::SpecializeImplicit(
     const SpecializationKey<Generic>& key) {
-  if (!key.generic->declaration()->body &&
-      IntrinsicDeclaration::DynamicCast(key.generic->declaration()->callable) ==
-          nullptr) {
+  base::Optional<Statement*> body = key.generic->CallableBody();
+  if (!body && IntrinsicDeclaration::DynamicCast(key.generic->declaration()) ==
+                   nullptr) {
     ReportError("missing specialization of ", key.generic->name(),
                 " with types <", key.specialized_types, "> declared at ",
                 key.generic->Position());
   }
   CurrentScope::Scope generic_scope(key.generic->ParentScope());
-  Callable* result = Specialize(key, key.generic->declaration()->callable,
-                                base::nullopt, key.generic->declaration()->body,
-                                CurrentSourcePosition::Get());
+  Callable* result = Specialize(key, key.generic->declaration(), base::nullopt,
+                                body, CurrentSourcePosition::Get());
   result->SetIsUserDefined(false);
   CurrentScope::Scope callable_scope(result);
   DeclareSpecializedTypes(key);
@@ -321,12 +293,11 @@ Callable* DeclarationVisitor::SpecializeImplicit(
 }
 
 Callable* DeclarationVisitor::Specialize(
-    const SpecializationKey<Generic>& key, CallableNode* declaration,
-    base::Optional<const CallableNodeSignature*> signature,
+    const SpecializationKey<Generic>& key, CallableDeclaration* declaration,
+    base::Optional<const SpecializationDeclaration*> explicit_specialization,
     base::Optional<Statement*> body, SourcePosition position) {
   CurrentSourcePosition::Scope pos_scope(position);
-  size_t generic_parameter_count =
-      key.generic->declaration()->generic_parameters.size();
+  size_t generic_parameter_count = key.generic->generic_parameters().size();
   if (generic_parameter_count != key.specialized_types.size()) {
     std::stringstream stream;
     stream << "number of template parameters ("
@@ -341,13 +312,15 @@ Callable* DeclarationVisitor::Specialize(
                 " with types <", key.specialized_types, ">");
   }
 
-  Signature type_signature = signature ? TypeVisitor::MakeSignature(*signature)
-                                       : MakeSpecializedSignature(key);
+  Signature type_signature =
+      explicit_specialization
+          ? TypeVisitor::MakeSignature(*explicit_specialization)
+          : MakeSpecializedSignature(key);
 
   std::string generated_name = Declarations::GetGeneratedCallableName(
-      declaration->name, key.specialized_types);
+      declaration->name->value, key.specialized_types);
   std::stringstream readable_name;
-  readable_name << declaration->name << "<";
+  readable_name << declaration->name->value << "<";
   bool first = true;
   for (const Type* t : key.specialized_types) {
     if (!first) readable_name << ", ";
@@ -357,11 +330,12 @@ Callable* DeclarationVisitor::Specialize(
   readable_name << ">";
   Callable* callable;
   if (MacroDeclaration::DynamicCast(declaration) != nullptr) {
-    callable = Declarations::CreateTorqueMacro(
-        generated_name, readable_name.str(), false, type_signature,
-        declaration->transitioning, *body, true);
+    callable =
+        Declarations::CreateTorqueMacro(generated_name, readable_name.str(),
+                                        false, type_signature, *body, true);
   } else if (IntrinsicDeclaration::DynamicCast(declaration) != nullptr) {
-    callable = Declarations::CreateIntrinsic(declaration->name, type_signature);
+    callable =
+        Declarations::CreateIntrinsic(declaration->name->value, type_signature);
   } else {
     BuiltinDeclaration* builtin = BuiltinDeclaration::cast(declaration);
     callable = CreateBuiltin(builtin, generated_name, readable_name.str(),

src/torque/declaration-visitor.h

@@ -45,7 +45,7 @@ class PredeclarationVisitor {
     }
   }
   static void Predeclare(GenericDeclaration* decl) {
-    Declarations::DeclareGeneric(decl->callable->name, decl);
+    Declarations::DeclareGeneric(decl->declaration->name->value, decl);
   }
 };
 
@@ -76,30 +76,15 @@ class DeclarationVisitor {
                                 std::string external_name,
                                 std::string readable_name, Signature signature,
                                 base::Optional<Statement*> body);
-  static void Visit(ExternalBuiltinDeclaration* decl,
-                    const Signature& signature,
-                    base::Optional<Statement*> body) {
-    Declarations::Declare(
-        decl->name,
-        CreateBuiltin(decl, decl->name, decl->name, signature, base::nullopt));
-  }
-
-  static void Visit(ExternalRuntimeDeclaration* decl, const Signature& sig,
-                    base::Optional<Statement*> body);
-  static void Visit(ExternalMacroDeclaration* decl, const Signature& sig,
-                    base::Optional<Statement*> body);
-  static void Visit(TorqueBuiltinDeclaration* decl, const Signature& signature,
-                    base::Optional<Statement*> body);
-  static void Visit(TorqueMacroDeclaration* decl, const Signature& signature,
-                    base::Optional<Statement*> body);
-  static void Visit(IntrinsicDeclaration* decl, const Signature& signature,
-                    base::Optional<Statement*> body);
 
-  static void Visit(CallableNode* decl, const Signature& signature,
-                    base::Optional<Statement*> body);
+  static void Visit(ExternalBuiltinDeclaration* decl);
+  static void Visit(ExternalRuntimeDeclaration* decl);
+  static void Visit(ExternalMacroDeclaration* decl);
+  static void Visit(TorqueBuiltinDeclaration* decl);
+  static void Visit(TorqueMacroDeclaration* decl);
+  static void Visit(IntrinsicDeclaration* decl);
 
   static void Visit(ConstDeclaration* decl);
-  static void Visit(StandardDeclaration* decl);
   static void Visit(GenericDeclaration* decl) {
     // The PredeclarationVisitor already handled this case.
   }
@@ -111,8 +96,8 @@ class DeclarationVisitor {
       const SpecializationKey<Generic>& key);
   static Callable* SpecializeImplicit(const SpecializationKey<Generic>& key);
   static Callable* Specialize(
-      const SpecializationKey<Generic>& key, CallableNode* declaration,
-      base::Optional<const CallableNodeSignature*> signature,
+      const SpecializationKey<Generic>& key, CallableDeclaration* declaration,
+      base::Optional<const SpecializationDeclaration*> explicit_specialization,
       base::Optional<Statement*> body, SourcePosition position);
 
  private:

src/torque/declarations.cc

@@ -165,43 +165,44 @@ const TypeAlias* Declarations::PredeclareTypeAlias(const Identifier* name,
   return Declare(name->value, std::move(alias_ptr));
 }
 
-TorqueMacro* Declarations::CreateTorqueMacro(
-    std::string external_name, std::string readable_name, bool exported_to_csa,
-    Signature signature, bool transitioning, base::Optional<Statement*> body,
-    bool is_user_defined) {
+TorqueMacro* Declarations::CreateTorqueMacro(std::string external_name,
+                                             std::string readable_name,
+                                             bool exported_to_csa,
+                                             Signature signature,
+                                             base::Optional<Statement*> body,
+                                             bool is_user_defined) {
   // TODO(tebbi): Switch to more predictable names to improve incremental
   // compilation.
   external_name += "_" + std::to_string(GlobalContext::FreshId());
   return RegisterDeclarable(std::unique_ptr<TorqueMacro>(new TorqueMacro(
       std::move(external_name), std::move(readable_name), std::move(signature),
-      transitioning, body, is_user_defined, exported_to_csa)));
+      body, is_user_defined, exported_to_csa)));
 }
 
 ExternMacro* Declarations::CreateExternMacro(
-    std::string name, std::string external_assembler_name, Signature signature,
-    bool transitioning) {
+    std::string name, std::string external_assembler_name,
+    Signature signature) {
   return RegisterDeclarable(std::unique_ptr<ExternMacro>(
       new ExternMacro(std::move(name), std::move(external_assembler_name),
-                      std::move(signature), transitioning)));
+                      std::move(signature))));
 }
 
 Macro* Declarations::DeclareMacro(
     const std::string& name, bool accessible_from_csa,
     base::Optional<std::string> external_assembler_name,
-    const Signature& signature, bool transitioning,
-    base::Optional<Statement*> body, base::Optional<std::string> op,
-    bool is_user_defined) {
+    const Signature& signature, base::Optional<Statement*> body,
+    base::Optional<std::string> op, bool is_user_defined) {
   if (TryLookupMacro(name, signature.GetExplicitTypes())) {
     ReportError("cannot redeclare macro ", name,
                 " with identical explicit parameters");
   }
   Macro* macro;
   if (external_assembler_name) {
-    macro = CreateExternMacro(name, std::move(*external_assembler_name),
-                              signature, transitioning);
+    macro =
+        CreateExternMacro(name, std::move(*external_assembler_name), signature);
   } else {
-    macro = CreateTorqueMacro(name, name, accessible_from_csa, signature,
-                              transitioning, body, is_user_defined);
+    macro = CreateTorqueMacro(name, name, accessible_from_csa, signature, body,
+                              is_user_defined);
   }
   Declare(name, macro);
   if (op) {
@@ -216,11 +217,11 @@ Macro* Declarations::DeclareMacro(
 
 Method* Declarations::CreateMethod(AggregateType* container_type,
                                    const std::string& name, Signature signature,
-                                   bool transitioning, Statement* body) {
+                                   Statement* body) {
   std::string generated_name{container_type->GetGeneratedMethodName(name)};
   Method* result = RegisterDeclarable(std::unique_ptr<Method>(
       new Method(container_type, container_type->GetGeneratedMethodName(name),
-                 name, std::move(signature), transitioning, body)));
+                 name, std::move(signature), body)));
   container_type->RegisterMethod(result);
   return result;
 }
@@ -242,29 +243,27 @@ Intrinsic* Declarations::DeclareIntrinsic(const std::string& name,
 Builtin* Declarations::CreateBuiltin(std::string external_name,
                                      std::string readable_name,
                                      Builtin::Kind kind, Signature signature,
-                                     bool transitioning,
+
                                      base::Optional<Statement*> body) {
   return RegisterDeclarable(std::unique_ptr<Builtin>(
       new Builtin(std::move(external_name), std::move(readable_name), kind,
-                  std::move(signature), transitioning, body)));
+                  std::move(signature), body)));
 }
 
 Builtin* Declarations::DeclareBuiltin(const std::string& name,
                                       Builtin::Kind kind,
                                       const Signature& signature,
-                                      bool transitioning,
+
                                       base::Optional<Statement*> body) {
   CheckAlreadyDeclared<Builtin>(name, "builtin");
-  return Declare(
-      name, CreateBuiltin(name, name, kind, signature, transitioning, body));
+  return Declare(name, CreateBuiltin(name, name, kind, signature, body));
 }
 
 RuntimeFunction* Declarations::DeclareRuntimeFunction(
-    const std::string& name, const Signature& signature, bool transitioning) {
+    const std::string& name, const Signature& signature) {
   CheckAlreadyDeclared<RuntimeFunction>(name, "runtime function");
-  return Declare(name,
-                 RegisterDeclarable(std::unique_ptr<RuntimeFunction>(
-                     new RuntimeFunction(name, signature, transitioning))));
+  return Declare(name, RegisterDeclarable(std::unique_ptr<RuntimeFunction>(
+                           new RuntimeFunction(name, signature))));
 }
 
 void Declarations::DeclareExternConstant(Identifier* name, const Type* type,

src/torque/declarations.h

@@ -88,23 +88,21 @@ class Declarations {
   static TorqueMacro* CreateTorqueMacro(std::string external_name,
                                         std::string readable_name,
                                         bool exported_to_csa,
-                                        Signature signature, bool transitioning,
+                                        Signature signature,
                                         base::Optional<Statement*> body,
                                         bool is_user_defined);
   static ExternMacro* CreateExternMacro(std::string name,
                                         std::string external_assembler_name,
-                                        Signature signature,
-                                        bool transitioning);
+                                        Signature signature);
   static Macro* DeclareMacro(
       const std::string& name, bool accessible_from_csa,
       base::Optional<std::string> external_assembler_name,
-      const Signature& signature, bool transitioning,
-      base::Optional<Statement*> body, base::Optional<std::string> op = {},
-      bool is_user_defined = true);
+      const Signature& signature, base::Optional<Statement*> body,
+      base::Optional<std::string> op = {}, bool is_user_defined = true);
 
   static Method* CreateMethod(AggregateType* class_type,
                               const std::string& name, Signature signature,
-                              bool transitioning, Statement* body);
+                              Statement* body);
 
   static Intrinsic* CreateIntrinsic(const std::string& name,
                                     const Signature& signature);
@@ -114,15 +112,14 @@ class Declarations {
 
   static Builtin* CreateBuiltin(std::string external_name,
                                 std::string readable_name, Builtin::Kind kind,
-                                Signature signature, bool transitioning,
+                                Signature signature,
                                 base::Optional<Statement*> body);
   static Builtin* DeclareBuiltin(const std::string& name, Builtin::Kind kind,
-                                 const Signature& signature, bool transitioning,
+                                 const Signature& signature,
                                  base::Optional<Statement*> body);
 
   static RuntimeFunction* DeclareRuntimeFunction(const std::string& name,
-                                                 const Signature& signature,
-                                                 bool transitioning);
+                                                 const Signature& signature);
 
   static void DeclareExternConstant(Identifier* name, const Type* type,
                                     std::string value);

src/torque/implementation-visitor.cc

@@ -108,7 +108,8 @@ void ImplementationVisitor::EndCSAFiles() {
 }
 
 void ImplementationVisitor::Visit(NamespaceConstant* decl) {
-  Signature signature{{}, base::nullopt, {{}, false}, 0, decl->type(), {}};
+  Signature signature{{}, base::nullopt, {{}, false}, 0, decl->type(),
+                      {}, false};
 
   BindingsManagersScope bindings_managers_scope;
 
@@ -2412,7 +2413,7 @@ VisitResult ImplementationVisitor::Visit(IntrinsicCallExpression* expr) {
   for (Expression* arg : expr->arguments)
     arguments.parameters.push_back(Visit(arg));
   return scope.Yield(
-      GenerateCall(expr->name, arguments, specialization_types, false));
+      GenerateCall(expr->name->value, arguments, specialization_types, false));
 }
 
 void ImplementationVisitor::GenerateBranch(const VisitResult& condition,

src/torque/torque-parser.cc

@@ -360,7 +360,7 @@ base::Optional<ParseResult> MakeBinaryOperator(
 
 base::Optional<ParseResult> MakeIntrinsicCallExpression(
     ParseResultIterator* child_results) {
-  auto callee = child_results->NextAs<std::string>();
+  auto callee = child_results->NextAs<Identifier*>();
   auto generic_arguments =
       child_results->NextAs<std::vector<TypeExpression*>>();
   auto args = child_results->NextAs<std::vector<Expression*>>();
@@ -472,29 +472,27 @@ base::Optional<ParseResult> MakeExternalMacro(
   auto operator_name = child_results->NextAs<base::Optional<std::string>>();
   auto external_assembler_name =
       child_results->NextAs<base::Optional<std::string>>();
-  auto name = child_results->NextAs<std::string>();
+  auto name = child_results->NextAs<Identifier*>();
   auto generic_parameters = child_results->NextAs<GenericParameters>();
   LintGenericParameters(generic_parameters);
 
   auto args = child_results->NextAs<ParameterList>();
   auto return_type = child_results->NextAs<TypeExpression*>();
   auto labels = child_results->NextAs<LabelAndTypesVector>();
-  MacroDeclaration* macro = MakeNode<ExternalMacroDeclaration>(
+
+  Declaration* result = MakeNode<ExternalMacroDeclaration>(
       transitioning,
       external_assembler_name ? *external_assembler_name : "CodeStubAssembler",
       name, operator_name, args, return_type, labels);
-  Declaration* result;
-  if (generic_parameters.empty()) {
-    result = MakeNode<StandardDeclaration>(macro, base::nullopt);
-  } else {
-    result = MakeNode<GenericDeclaration>(macro, generic_parameters);
+  if (!generic_parameters.empty()) {
+    Error("External builtins cannot be generic.");
   }
   return ParseResult{result};
 }
 
 base::Optional<ParseResult> MakeIntrinsicDeclaration(
     ParseResultIterator* child_results) {
-  auto name = child_results->NextAs<std::string>();
+  auto name = child_results->NextAs<Identifier*>();
   auto generic_parameters = child_results->NextAs<GenericParameters>();
   LintGenericParameters(generic_parameters);
 
@@ -502,19 +500,17 @@ base::Optional<ParseResult> MakeIntrinsicDeclaration(
   auto return_type = child_results->NextAs<TypeExpression*>();
   auto body = child_results->NextAs<base::Optional<Statement*>>();
   LabelAndTypesVector labels;
-  CallableNode* callable = nullptr;
+  CallableDeclaration* declaration;
   if (body) {
-    callable = MakeNode<TorqueMacroDeclaration>(
+    declaration = MakeNode<TorqueMacroDeclaration>(
         false, name, base::Optional<std::string>{}, args, return_type, labels,
-        false);
+        false, body);
   } else {
-    callable = MakeNode<IntrinsicDeclaration>(name, args, return_type);
+    declaration = MakeNode<IntrinsicDeclaration>(name, args, return_type);
   }
-  Declaration* result;
-  if (generic_parameters.empty()) {
-    result = MakeNode<StandardDeclaration>(callable, body);
-  } else {
-    result = MakeNode<GenericDeclaration>(callable, generic_parameters, body);
+  Declaration* result = declaration;
+  if (!generic_parameters.empty()) {
+    result = MakeNode<GenericDeclaration>(generic_parameters, declaration);
   }
   return ParseResult{result};
 }
@@ -524,8 +520,8 @@ base::Optional<ParseResult> MakeTorqueMacroDeclaration(
   auto export_to_csa = child_results->NextAs<bool>();
   auto transitioning = child_results->NextAs<bool>();
   auto operator_name = child_results->NextAs<base::Optional<std::string>>();
-  auto name = child_results->NextAs<std::string>();
-  if (!IsUpperCamelCase(name)) {
+  auto name = child_results->NextAs<Identifier*>();
+  if (!IsUpperCamelCase(name->value)) {
     NamingConventionError("Macro", name, "UpperCamelCase");
   }
 
@@ -536,16 +532,15 @@ base::Optional<ParseResult> MakeTorqueMacroDeclaration(
   auto return_type = child_results->NextAs<TypeExpression*>();
   auto labels = child_results->NextAs<LabelAndTypesVector>();
   auto body = child_results->NextAs<base::Optional<Statement*>>();
-  MacroDeclaration* macro =
-      MakeNode<TorqueMacroDeclaration>(transitioning, name, operator_name, args,
-                                       return_type, labels, export_to_csa);
-  Declaration* result;
+  CallableDeclaration* declaration = MakeNode<TorqueMacroDeclaration>(
+      transitioning, name, operator_name, args, return_type, labels,
+      export_to_csa, body);
+  Declaration* result = declaration;
   if (generic_parameters.empty()) {
     if (!body) ReportError("A non-generic declaration needs a body.");
-    result = MakeNode<StandardDeclaration>(macro, *body);
   } else {
     if (export_to_csa) ReportError("Cannot export generics to CSA.");
-    result = MakeNode<GenericDeclaration>(macro, generic_parameters, body);
+    result = MakeNode<GenericDeclaration>(generic_parameters, declaration);
   }
   return ParseResult{result};
 }
@@ -554,8 +549,8 @@ base::Optional<ParseResult> MakeTorqueBuiltinDeclaration(
     ParseResultIterator* child_results) {
   auto transitioning = child_results->NextAs<bool>();
   auto javascript_linkage = child_results->NextAs<bool>();
-  auto name = child_results->NextAs<std::string>();
-  if (!IsUpperCamelCase(name)) {
+  auto name = child_results->NextAs<Identifier*>();
+  if (!IsUpperCamelCase(name->value)) {
     NamingConventionError("Builtin", name, "UpperCamelCase");
   }
 
@@ -565,14 +560,13 @@ base::Optional<ParseResult> MakeTorqueBuiltinDeclaration(
   auto args = child_results->NextAs<ParameterList>();
   auto return_type = child_results->NextAs<TypeExpression*>();
   auto body = child_results->NextAs<base::Optional<Statement*>>();
-  BuiltinDeclaration* builtin = MakeNode<TorqueBuiltinDeclaration>(
-      transitioning, javascript_linkage, name, args, return_type);
-  Declaration* result;
+  CallableDeclaration* declaration = MakeNode<TorqueBuiltinDeclaration>(
+      transitioning, javascript_linkage, name, args, return_type, body);
+  Declaration* result = declaration;
   if (generic_parameters.empty()) {
     if (!body) ReportError("A non-generic declaration needs a body.");
-    result = MakeNode<StandardDeclaration>(builtin, *body);
   } else {
-    result = MakeNode<GenericDeclaration>(builtin, generic_parameters, body);
+    result = MakeNode<GenericDeclaration>(generic_parameters, declaration);
   }
   return ParseResult{result};
 }
@@ -649,8 +643,8 @@ base::Optional<ParseResult> MakeMethodDeclaration(
     ParseResultIterator* child_results) {
   auto transitioning = child_results->NextAs<bool>();
   auto operator_name = child_results->NextAs<base::Optional<std::string>>();
-  auto name = child_results->NextAs<std::string>();
-  if (!IsUpperCamelCase(name)) {
+  auto name = child_results->NextAs<Identifier*>();
+  if (!IsUpperCamelCase(name->value)) {
     NamingConventionError("Method", name, "UpperCamelCase");
   }
 
@@ -658,9 +652,9 @@ base::Optional<ParseResult> MakeMethodDeclaration(
   auto return_type = child_results->NextAs<TypeExpression*>();
   auto labels = child_results->NextAs<LabelAndTypesVector>();
   auto body = child_results->NextAs<Statement*>();
-  MacroDeclaration* macro = MakeNode<TorqueMacroDeclaration>(
-      transitioning, name, operator_name, args, return_type, labels, false);
-  Declaration* result = MakeNode<StandardDeclaration>(macro, body);
+  Declaration* result =
+      MakeNode<TorqueMacroDeclaration>(transitioning, name, operator_name, args,
+                                       return_type, labels, false, body);
   return ParseResult{result};
 }
 
@@ -756,6 +750,7 @@ base::Optional<ParseResult> MakeNamespaceDeclaration(
 
 base::Optional<ParseResult> MakeSpecializationDeclaration(
     ParseResultIterator* child_results) {
+  auto transitioning = child_results->NextAs<bool>();
   auto name = child_results->NextAs<Identifier*>();
   auto generic_parameters =
       child_results->NextAs<std::vector<TypeExpression*>>();
@@ -765,8 +760,8 @@ base::Optional<ParseResult> MakeSpecializationDeclaration(
   auto body = child_results->NextAs<Statement*>();
   CheckNotDeferredStatement(body);
   Declaration* result = MakeNode<SpecializationDeclaration>(
-      std::move(name), std::move(generic_parameters), std::move(parameters),
-      return_type, std::move(labels), body);
+      transitioning, std::move(name), std::move(generic_parameters),
+      std::move(parameters), return_type, std::move(labels), body);
   return ParseResult{result};
 }
 
@@ -817,19 +812,16 @@ base::Optional<ParseResult> MakeExternalBuiltin(
     ParseResultIterator* child_results) {
   auto transitioning = child_results->NextAs<bool>();
   auto js_linkage = child_results->NextAs<bool>();
-  auto name = child_results->NextAs<std::string>();
+  auto name = child_results->NextAs<Identifier*>();
   auto generic_parameters = child_results->NextAs<GenericParameters>();
   LintGenericParameters(generic_parameters);
 
   auto args = child_results->NextAs<ParameterList>();
   auto return_type = child_results->NextAs<TypeExpression*>();
-  BuiltinDeclaration* builtin = MakeNode<ExternalBuiltinDeclaration>(
+  Declaration* result = MakeNode<ExternalBuiltinDeclaration>(
       transitioning, js_linkage, name, args, return_type);
-  Declaration* result;
-  if (generic_parameters.empty()) {
-    result = MakeNode<StandardDeclaration>(builtin, base::nullopt);
-  } else {
-    result = MakeNode<GenericDeclaration>(builtin, generic_parameters);
+  if (!generic_parameters.empty()) {
+    Error("External builtins cannot be generic.");
   }
   return ParseResult{result};
 }
@@ -837,12 +829,11 @@ base::Optional<ParseResult> MakeExternalBuiltin(
 base::Optional<ParseResult> MakeExternalRuntime(
     ParseResultIterator* child_results) {
   auto transitioning = child_results->NextAs<bool>();
-  auto name = child_results->NextAs<std::string>();
+  auto name = child_results->NextAs<Identifier*>();
   auto args = child_results->NextAs<ParameterList>();
   auto return_type = child_results->NextAs<TypeExpression*>();
-  ExternalRuntimeDeclaration* runtime = MakeNode<ExternalRuntimeDeclaration>(
+  Declaration* result = MakeNode<ExternalRuntimeDeclaration>(
       transitioning, name, args, return_type);
-  Declaration* result = MakeNode<StandardDeclaration>(runtime, base::nullopt);
   return ParseResult{result};
 }
 
@@ -1491,7 +1482,7 @@ struct TorqueGrammar : Grammar {
 
   // Result: std::string
   Symbol intrinsicName = {
-      Rule({Pattern(MatchIntrinsicName)}, YieldMatchedInput)};
+      Rule({Pattern(MatchIntrinsicName)}, MakeIdentifierFromMatchedInput)};
 
   // Result: std::string
   Symbol stringLiteral = {
@@ -1861,8 +1852,8 @@ struct TorqueGrammar : Grammar {
   Symbol method = {Rule(
       {CheckIf(Token("transitioning")),
        Optional<std::string>(Sequence({Token("operator"), &externalString})),
-       &identifier, &parameterListNoVararg, &optionalReturnType,
-       optionalLabelList, &block},
+       &name, &parameterListNoVararg, &optionalReturnType, optionalLabelList,
+       &block},
       MakeMethodDeclaration)};
 
   // Result: std::vector<Declaration*>
@@ -1904,34 +1895,34 @@ struct TorqueGrammar : Grammar {
             Optional<std::string>(
                 Sequence({Token("operator"), &externalString})),
             Token("macro"),
-            Optional<std::string>(Sequence({&identifier, Token("::")})),
-            &identifier, TryOrDefault<GenericParameters>(&genericParameters),
+            Optional<std::string>(Sequence({&identifier, Token("::")})), &name,
+            TryOrDefault<GenericParameters>(&genericParameters),
             &typeListMaybeVarArgs, &optionalReturnType, optionalLabelList,
             Token(";")},
            AsSingletonVector<Declaration*, MakeExternalMacro>()),
       Rule({Token("extern"), CheckIf(Token("transitioning")),
-            CheckIf(Token("javascript")), Token("builtin"), &identifier,
+            CheckIf(Token("javascript")), Token("builtin"), &name,
             TryOrDefault<GenericParameters>(&genericParameters),
             &typeListMaybeVarArgs, &optionalReturnType, Token(";")},
            AsSingletonVector<Declaration*, MakeExternalBuiltin>()),
-      Rule(
-          {Token("extern"), CheckIf(Token("transitioning")), Token("runtime"),
-           &identifier, &typeListMaybeVarArgs, &optionalReturnType, Token(";")},
-          AsSingletonVector<Declaration*, MakeExternalRuntime>()),
+      Rule({Token("extern"), CheckIf(Token("transitioning")), Token("runtime"),
+            &name, &typeListMaybeVarArgs, &optionalReturnType, Token(";")},
+           AsSingletonVector<Declaration*, MakeExternalRuntime>()),
       Rule({CheckIf(Token("@export")), CheckIf(Token("transitioning")),
             Optional<std::string>(
                 Sequence({Token("operator"), &externalString})),
-            Token("macro"), &identifier,
+            Token("macro"), &name,
             TryOrDefault<GenericParameters>(&genericParameters),
             &parameterListNoVararg, &optionalReturnType, optionalLabelList,
             &optionalBody},
            AsSingletonVector<Declaration*, MakeTorqueMacroDeclaration>()),
       Rule({CheckIf(Token("transitioning")), CheckIf(Token("javascript")),
-            Token("builtin"), &identifier,
+            Token("builtin"), &name,
             TryOrDefault<GenericParameters>(&genericParameters),
             &parameterListAllowVararg, &optionalReturnType, &optionalBody},
            AsSingletonVector<Declaration*, MakeTorqueBuiltinDeclaration>()),
-      Rule({&name, &genericSpecializationTypeList, &parameterListAllowVararg,
+      Rule({CheckIf(Token("transitioning")), &name,
+            &genericSpecializationTypeList, &parameterListAllowVararg,
             &optionalReturnType, optionalLabelList, &block},
            AsSingletonVector<Declaration*, MakeSpecializationDeclaration>()),
       Rule({Token("#include"), &externalString},

src/torque/type-visitor.cc

@@ -92,22 +92,18 @@ void DeclareMethods(AggregateType* container_type,
                     const std::vector<Declaration*>& methods) {
   for (auto declaration : methods) {
     CurrentSourcePosition::Scope pos_scope(declaration->pos);
-    StandardDeclaration* standard_declaration =
-        StandardDeclaration::DynamicCast(declaration);
-    DCHECK(standard_declaration);
     TorqueMacroDeclaration* method =
-        TorqueMacroDeclaration::DynamicCast(standard_declaration->callable);
-    Signature signature = TypeVisitor::MakeSignature(method->signature.get());
+        TorqueMacroDeclaration::DynamicCast(declaration);
+    Signature signature = TypeVisitor::MakeSignature(method);
     signature.parameter_names.insert(
         signature.parameter_names.begin() + signature.implicit_count,
         MakeNode<Identifier>(kThisParameterName));
-    Statement* body = *(standard_declaration->body);
-    std::string method_name(method->name);
+    Statement* body = *(method->body);
+    const std::string& method_name(method->name->value);
     signature.parameter_types.types.insert(
         signature.parameter_types.types.begin() + signature.implicit_count,
         container_type);
-    Declarations::CreateMethod(container_type, method_name, signature, false,
-                               body);
+    Declarations::CreateMethod(container_type, method_name, signature, body);
   }
 }
 
@@ -231,22 +227,23 @@ const Type* TypeVisitor::ComputeType(TypeExpression* type_expression) {
   }
 }
 
-Signature TypeVisitor::MakeSignature(const CallableNodeSignature* signature) {
+Signature TypeVisitor::MakeSignature(const CallableDeclaration* declaration) {
   LabelDeclarationVector definition_vector;
-  for (const auto& label : signature->labels) {
+  for (const auto& label : declaration->labels) {
     LabelDeclaration def = {label.name, ComputeTypeVector(label.types)};
     definition_vector.push_back(def);
   }
   base::Optional<std::string> arguments_variable;
-  if (signature->parameters.has_varargs)
-    arguments_variable = signature->parameters.arguments_variable;
-  Signature result{signature->parameters.names,
+  if (declaration->parameters.has_varargs)
+    arguments_variable = declaration->parameters.arguments_variable;
+  Signature result{declaration->parameters.names,
                    arguments_variable,
-                   {ComputeTypeVector(signature->parameters.types),
-                    signature->parameters.has_varargs},
-                   signature->parameters.implicit_count,
-                   ComputeType(signature->return_type),
-                   definition_vector};
+                   {ComputeTypeVector(declaration->parameters.types),
+                    declaration->parameters.has_varargs},
+                   declaration->parameters.implicit_count,
+                   ComputeType(declaration->return_type),
+                   definition_vector,
+                   declaration->transitioning};
   return result;
 }
 

src/torque/type-visitor.h

@@ -27,7 +27,7 @@ class TypeVisitor {
   static const Type* ComputeType(TypeExpression* type_expression);
   static void VisitClassFieldsAndMethods(
       ClassType* class_type, const ClassDeclaration* class_declaration);
-  static Signature MakeSignature(const CallableNodeSignature* signature);
+  static Signature MakeSignature(const CallableDeclaration* declaration);
   static const StructType* ComputeTypeForStructExpression(
       TypeExpression* type_expression,
       const std::vector<const Type*>& term_argument_types);

src/torque/types.cc

@@ -453,8 +453,7 @@ void ClassType::GenerateAccessors() {
         MakeNode<ReturnStatement>(MakeNode<FieldAccessExpression>(
             parameter, MakeNode<Identifier>(field.name_and_type.name)));
     Declarations::DeclareMacro(load_macro_name, true, base::nullopt,
-                               load_signature, false, load_body, base::nullopt,
-                               false);
+                               load_signature, load_body, base::nullopt);
 
     // Store accessor
     IdentifierExpression* value = MakeNode<IdentifierExpression>(
@@ -474,8 +473,8 @@ void ClassType::GenerateAccessors() {
                 parameter, MakeNode<Identifier>(field.name_and_type.name)),
             value));
     Declarations::DeclareMacro(store_macro_name, true, base::nullopt,
-                               store_signature, false, store_body,
-                               base::nullopt, false);
+                               store_signature, store_body, base::nullopt,
+                               false);
   }
 }
 

src/torque/types.h

@@ -647,22 +647,25 @@ using NameVector = std::vector<Identifier*>;
 
 struct Signature {
   Signature(NameVector n, base::Optional<std::string> arguments_variable,
-            ParameterTypes p, size_t i, const Type* r, LabelDeclarationVector l)
+            ParameterTypes p, size_t i, const Type* r, LabelDeclarationVector l,
+            bool transitioning)
       : parameter_names(std::move(n)),
         arguments_variable(arguments_variable),
         parameter_types(std::move(p)),
         implicit_count(i),
         return_type(r),
-        labels(std::move(l)) {}
-  Signature() : implicit_count(0), return_type(nullptr) {}
+        labels(std::move(l)),
+        transitioning(transitioning) {}
+  Signature() = default;
   const TypeVector& types() const { return parameter_types.types; }
   NameVector parameter_names;
   base::Optional<std::string> arguments_variable;
   ParameterTypes parameter_types;
-  size_t implicit_count;
+  size_t implicit_count = 0;
   size_t ExplicitCount() const { return types().size() - implicit_count; }
   const Type* return_type;
   LabelDeclarationVector labels;
+  bool transitioning = false;
   bool HasSameTypesAs(
       const Signature& other,
       ParameterMode mode = ParameterMode::kProcessImplicit) const;