[torque] cleanup generics and scopes

- Name lookup in module scopes has namespace semantics now: All
  overloads from all parent modules are combined before overload
  resolution.
- Allow overloads of different callables: runtime-functions,
  macros, builtins, and generics.
- The duplication between the DeclarationVisitor and the
  ImplementationVisitor is removed: The DeclarationVisitor creates
  declarables for everything except for implicit generic specializations.
  The ImplementationVisitor iterates over declarables.
  The DeclarationVisitor only looks at the header of declarations, not
  at the body.
- Modules become Declarable's, which will enable them to be nested.
- Modules replace the existing Scope chain mechanism, which will make it
  easier to inline macros.
- The DeclarationVisitor and Declarations become stateless. All state is
  moved to contextual variables and the GlobalContext.
- Implicit specializations are created directly from the
  ImplementationVisitor. This will enable template parameter inference.
- As a consequence, the list of all builtins is only available after the
  ImplementationVisitor has run. Thus GenerateBuiltinDefinitions has to
  move to the ImplementationVisitor. Also, this makes it necessary to
  resolve the link from function pointer types to example builtins only
  at this point.


Bug: v8:7793
Change-Id: I61cef2fd3e954ab148c252974344a6e38ee2d01d
Reviewed-on: https://chromium-review.googlesource.com/c/1304294
Commit-Queue: Tobias Tebbi <tebbi@chromium.org>
Reviewed-by: Daniel Clifford <danno@chromium.org>
Cr-Commit-Position: refs/heads/master@{#57231}

BUILD.gn

@@ -3063,8 +3063,6 @@ v8_source_set("torque_base") {
     "src/torque/implementation-visitor.h",
     "src/torque/instructions.cc",
     "src/torque/instructions.h",
-    "src/torque/scope.cc",
-    "src/torque/scope.h",
     "src/torque/source-positions.cc",
     "src/torque/source-positions.h",
     "src/torque/torque-parser.cc",

src/builtins/base.tq

@@ -748,6 +748,9 @@ macro UnsafeCast<A: type>(n: Number): A;
 UnsafeCast<HeapNumber>(n: Number): HeapNumber {
   return UnsafeCastNumberToHeapNumber(n);
 }
+UnsafeCast<Smi>(o: Number): Smi {
+  return UnsafeCastObjectToSmi(o);
+}
 macro UnsafeCast<A: type>(o: Object): A;
 UnsafeCast<Object>(o: Object): Object {
   return o;
@@ -821,7 +824,6 @@ macro BranchIfJSArgumentsObjectWithLength(implicit context: Context)(o: Object):
   goto True;
 }
 
-macro UnsafeCast<A: type>(implicit context: Context)(o: Object): A;
 UnsafeCast<JSArgumentsObjectWithLength>(implicit context: Context)(o: Object):
     JSArgumentsObjectWithLength {
   assert(BranchIfJSArgumentsObjectWithLength(o));

src/builtins/builtins.cc

@@ -372,5 +372,18 @@ bool Builtins::AllowDynamicFunction(Isolate* isolate, Handle<JSFunction> target,
   return isolate->MayAccess(responsible_context, target_global_proxy);
 }
 
+Builtins::Name ExampleBuiltinForTorqueFunctionPointerType(
+    size_t function_pointer_type_id) {
+  switch (function_pointer_type_id) {
+#define FUNCTION_POINTER_ID_CASE(id, name) \
+  case id:                                 \
+    return Builtins::k##name;
+    TORQUE_FUNCTION_POINTER_TYPE_TO_BUILTIN_MAP(FUNCTION_POINTER_ID_CASE)
+#undef FUNCTION_POINTER_ID_CASE
+    default:
+      UNREACHABLE();
+  }
+}
+
 }  // namespace internal
 }  // namespace v8

src/builtins/builtins.h

@@ -208,6 +208,9 @@ class Builtins {
   DISALLOW_COPY_AND_ASSIGN(Builtins);
 };
 
+Builtins::Name ExampleBuiltinForTorqueFunctionPointerType(
+    size_t function_pointer_type_id);
+
 }  // namespace internal
 }  // namespace v8
 

src/torque/ast.h

@@ -63,8 +63,7 @@ namespace torque {
   V(SpecializationDeclaration)            \
   V(ExternConstDeclaration)               \
   V(StructDeclaration)                    \
-  V(DefaultModuleDeclaration)             \
-  V(ExplicitModuleDeclaration)            \
+  V(ModuleDeclaration)                    \
   V(ConstDeclaration)
 
 #define AST_CALLABLE_NODE_KIND_LIST(V) \
@@ -155,46 +154,23 @@ struct Statement : AstNode {
 class Module;
 
 struct ModuleDeclaration : Declaration {
-  ModuleDeclaration(AstNode::Kind kind, SourcePosition pos,
+  DEFINE_AST_NODE_LEAF_BOILERPLATE(ModuleDeclaration)
+  ModuleDeclaration(SourcePosition pos, std::string name,
                     std::vector<Declaration*> declarations)
-      : Declaration(kind, pos),
-        module(nullptr),
-        declarations(std::move(declarations)) {}
-  virtual bool IsDefault() const = 0;
-  //  virtual std::string GetName() const = 0;
-  void SetModule(Module* m) { module = m; }
-  Module* GetModule() const { return module; }
-  Module* module;
+      : Declaration(kKind, pos),
+        declarations(std::move(declarations)),
+        name(name) {}
   std::vector<Declaration*> declarations;
-};
-
-struct DefaultModuleDeclaration : ModuleDeclaration {
-  DEFINE_AST_NODE_LEAF_BOILERPLATE(DefaultModuleDeclaration)
-  DefaultModuleDeclaration(SourcePosition pos,
-                           std::vector<Declaration*> declarations)
-      : ModuleDeclaration(kKind, pos, std::move(declarations)) {}
-  bool IsDefault() const override { return true; }
-};
-
-struct ExplicitModuleDeclaration : ModuleDeclaration {
-  DEFINE_AST_NODE_LEAF_BOILERPLATE(ExplicitModuleDeclaration)
-  ExplicitModuleDeclaration(SourcePosition pos, std::string name,
-                            std::vector<Declaration*> declarations)
-      : ModuleDeclaration(kKind, pos, std::move(declarations)),
-        name(std::move(name)) {}
-  bool IsDefault() const override { return false; }
   std::string name;
 };
 
 class Ast {
  public:
-  Ast() : default_module_{SourcePosition{CurrentSourceFile::Get(), 0, 0}, {}} {}
+  Ast() {}
 
-  std::vector<Declaration*>& declarations() {
-    return default_module_.declarations;
-  }
+  std::vector<Declaration*>& declarations() { return declarations_; }
   const std::vector<Declaration*>& declarations() const {
-    return default_module_.declarations;
+    return declarations_;
   }
   template <class T>
   T* AddNode(std::unique_ptr<T> node) {
@@ -202,10 +178,9 @@ class Ast {
     nodes_.push_back(std::move(node));
     return result;
   }
-  DefaultModuleDeclaration* default_module() { return &default_module_; }
 
  private:
-  DefaultModuleDeclaration default_module_;
+  std::vector<Declaration*> declarations_;
   std::vector<std::unique_ptr<AstNode>> nodes_;
 };
 
@@ -690,6 +665,7 @@ struct TorqueMacroDeclaration : MacroDeclaration {
 };
 
 struct BuiltinDeclaration : CallableNode {
+  DEFINE_AST_NODE_INNER_BOILERPLATE(BuiltinDeclaration)
   BuiltinDeclaration(AstNode::Kind kind, SourcePosition pos,
                      bool javascript_linkage, bool transitioning,
                      std::string name, ParameterList parameters,
@@ -747,10 +723,10 @@ struct ConstDeclaration : Declaration {
 struct StandardDeclaration : Declaration {
   DEFINE_AST_NODE_LEAF_BOILERPLATE(StandardDeclaration)
   StandardDeclaration(SourcePosition pos, CallableNode* callable,
-                      Statement* body)
+                      base::Optional<Statement*> body)
       : Declaration(kKind, pos), callable(callable), body(body) {}
   CallableNode* callable;
-  Statement* body;
+  base::Optional<Statement*> body;
 };
 
 struct GenericDeclaration : Declaration {

src/torque/csa-generator.cc

@@ -348,13 +348,14 @@ void CSAGenerator::EmitInstruction(
   std::vector<std::string> function_and_arguments =
       stack->PopMany(1 + instruction.argc);
   std::vector<const Type*> result_types =
-      LowerType(instruction.example_builtin->signature().return_type);
+      LowerType(instruction.type->return_type());
   if (result_types.size() != 1) {
     ReportError("builtins must have exactly one result");
   }
   if (instruction.is_tailcall) {
-    out_ << "    Tail (Builtins::CallableFor(isolate(), Builtins::k"
-         << instruction.example_builtin->name() << ").descriptor(), ";
+    out_ << "    Tail (Builtins::CallableFor(isolate(), "
+            "ExampleBuiltinForTorqueFunctionPointerType("
+         << instruction.type->function_pointer_type_id() << ")).descriptor(), ";
     PrintCommaSeparatedList(out_, function_and_arguments);
     out_ << ");\n";
   } else {
@@ -362,8 +363,9 @@ void CSAGenerator::EmitInstruction(
     std::string generated_type = result_types[0]->GetGeneratedTNodeTypeName();
     out_ << "    TNode<" << generated_type << "> " << stack->Top() << " = ";
     if (generated_type != "Object") out_ << "CAST(";
-    out_ << "CallStub(Builtins::CallableFor(isolate(), Builtins::k"
-         << instruction.example_builtin->name() << ").descriptor(), ";
+    out_ << "CallStub(Builtins::CallableFor(isolate(),"
+            "ExampleBuiltinForTorqueFunctionPointerType("
+         << instruction.type->function_pointer_type_id() << ")).descriptor(), ";
     PrintCommaSeparatedList(out_, function_and_arguments);
     out_ << ")";
     if (generated_type != "Object") out_ << ")";

src/torque/declarable.cc

@@ -11,12 +11,10 @@ namespace v8 {
 namespace internal {
 namespace torque {
 
+DEFINE_CONTEXTUAL_VARIABLE(CurrentScope);
+
 std::ostream& operator<<(std::ostream& os, const Callable& m) {
-  if (m.generic()) {
-    os << "callable " << (*m.generic())->name() << "(";
-  } else {
   os << "callable " << m.name() << "(";
-  }
   if (m.signature().implicit_count != 0) {
     os << "implicit ";
     TypeVector implicit_parameter_types(

src/torque/declarable.h

@@ -7,6 +7,7 @@
 
 #include <cassert>
 #include <string>
+#include <unordered_map>
 
 #include "src/base/functional.h"
 #include "src/base/logging.h"
@@ -18,43 +19,47 @@ namespace v8 {
 namespace internal {
 namespace torque {
 
-class Block;
-class Generic;
 class Scope;
-class ScopeChain;
+
+DECLARE_CONTEXTUAL_VARIABLE(CurrentScope, Scope*);
 
 class Declarable {
  public:
   virtual ~Declarable() = default;
   enum Kind {
+    kModule,
     kMacro,
-    kMacroList,
     kBuiltin,
     kRuntimeFunction,
     kGeneric,
-    kGenericList,
     kTypeAlias,
     kExternConstant,
     kModuleConstant
   };
   Kind kind() const { return kind_; }
+  bool IsModule() const { return kind() == kModule; }
   bool IsMacro() const { return kind() == kMacro; }
   bool IsBuiltin() const { return kind() == kBuiltin; }
   bool IsRuntimeFunction() const { return kind() == kRuntimeFunction; }
   bool IsGeneric() const { return kind() == kGeneric; }
   bool IsTypeAlias() const { return kind() == kTypeAlias; }
-  bool IsMacroList() const { return kind() == kMacroList; }
-  bool IsGenericList() const { return kind() == kGenericList; }
   bool IsExternConstant() const { return kind() == kExternConstant; }
   bool IsModuleConstant() const { return kind() == kModuleConstant; }
   bool IsValue() const { return IsExternConstant() || IsModuleConstant(); }
+  bool IsCallable() const {
+    return IsMacro() || IsBuiltin() || IsRuntimeFunction();
+  }
   virtual const char* type_name() const { return "<<unknown>>"; }
+  Scope* ParentScope() const { return parent_scope_; }
+  const SourcePosition& pos() const { return pos_; }
 
  protected:
   explicit Declarable(Kind kind) : kind_(kind) {}
 
  private:
   const Kind kind_;
+  Scope* const parent_scope_ = CurrentScope::Get();
+  SourcePosition pos_ = CurrentSourcePosition::Get();
 };
 
 #define DECLARE_DECLARABLE_BOILERPLATE(x, y)                  \
@@ -78,6 +83,61 @@ class Declarable {
     return static_cast<const x*>(declarable);                 \
   }
 
+class Scope : public Declarable {
+ public:
+  explicit Scope(Declarable::Kind kind) : Declarable(kind) {}
+
+  const std::vector<Declarable*>& LookupShallow(const std::string& name) {
+    return declarations_[name];
+  }
+
+  std::vector<Declarable*> Lookup(const std::string& name) {
+    std::vector<Declarable*> result;
+    if (ParentScope()) {
+      result = ParentScope()->Lookup(name);
+    }
+    for (Declarable* declarable : declarations_[name]) {
+      result.push_back(declarable);
+    }
+    return result;
+  }
+  template <class T>
+  T* AddDeclarable(const std::string& name, T* declarable) {
+    declarations_[name].push_back(declarable);
+    return declarable;
+  }
+
+ private:
+  std::unordered_map<std::string, std::vector<Declarable*>> declarations_;
+};
+
+class Module : public Scope {
+ public:
+  DECLARE_DECLARABLE_BOILERPLATE(Module, module);
+  explicit Module(const std::string& name)
+      : Scope(Declarable::kModule), name_(name) {}
+  const std::string& name() const { return name_; }
+  std::ostream& source_stream() { return source_stream_; }
+  std::ostream& header_stream() { return header_stream_; }
+  std::string source() { return source_stream_.str(); }
+  std::string header() { return header_stream_.str(); }
+
+ private:
+  std::string name_;
+  std::stringstream header_stream_;
+  std::stringstream source_stream_;
+};
+
+inline Module* CurrentModule() {
+  Scope* scope = CurrentScope::Get();
+  while (true) {
+    if (Module* m = Module::DynamicCast(scope)) {
+      return m;
+    }
+    scope = scope->ParentScope();
+  }
+}
+
 class Value : public Declarable {
  public:
   DECLARE_DECLARABLE_BOILERPLATE(Value, value);
@@ -106,14 +166,18 @@ class ModuleConstant : public Value {
   DECLARE_DECLARABLE_BOILERPLATE(ModuleConstant, constant);
 
   const std::string& constant_name() const { return constant_name_; }
+  Expression* body() { return body_; }
 
  private:
   friend class Declarations;
-  explicit ModuleConstant(std::string constant_name, const Type* type)
+  explicit ModuleConstant(std::string constant_name, const Type* type,
+                          Expression* body)
       : Value(Declarable::kModuleConstant, type, constant_name),
-        constant_name_(std::move(constant_name)) {}
+        constant_name_(std::move(constant_name)),
+        body_(body) {}
 
   std::string constant_name_;
+  Expression* body_;
 };
 
 class ExternConstant : public Value {
@@ -128,18 +192,9 @@ class ExternConstant : public Value {
   }
 };
 
-class Callable : public Declarable {
+class Callable : public Scope {
  public:
-  static Callable* cast(Declarable* declarable) {
-    assert(declarable->IsMacro() || declarable->IsBuiltin() ||
-           declarable->IsRuntimeFunction());
-    return static_cast<Callable*>(declarable);
-  }
-  static const Callable* cast(const Declarable* declarable) {
-    assert(declarable->IsMacro() || declarable->IsBuiltin() ||
-           declarable->IsRuntimeFunction());
-    return static_cast<const Callable*>(declarable);
-  }
+  DECLARE_DECLARABLE_BOILERPLATE(Callable, callable);
   const std::string& name() const { return name_; }
   const Signature& signature() const { return signature_; }
   const NameVector& parameter_names() const {
@@ -151,25 +206,28 @@ class Callable : public Declarable {
   void IncrementReturns() { ++returns_; }
   bool HasReturns() const { return returns_; }
   bool IsTransitioning() const { return transitioning_; }
-  base::Optional<Generic*> generic() const { return generic_; }
+  base::Optional<Statement*> body() const { return body_; }
+  bool IsExternal() const { return !body_.has_value(); }
 
  protected:
   Callable(Declarable::Kind kind, const std::string& name,
            const Signature& signature, bool transitioning,
-           base::Optional<Generic*> generic)
-      : Declarable(kind),
+           base::Optional<Statement*> body)
+      : Scope(kind),
         name_(name),
         signature_(signature),
         transitioning_(transitioning),
         returns_(0),
-        generic_(generic) {}
+        body_(body) {
+    DCHECK(!body || *body);
+  }
 
  private:
   std::string name_;
   Signature signature_;
   bool transitioning_;
   size_t returns_;
-  base::Optional<Generic*> generic_;
+  base::Optional<Statement*> body_;
 };
 
 class Macro : public Callable {
@@ -179,30 +237,14 @@ class Macro : public Callable {
  private:
   friend class Declarations;
   Macro(const std::string& name, const Signature& signature, bool transitioning,
-        base::Optional<Generic*> generic)
-      : Callable(Declarable::kMacro, name, signature, transitioning, generic) {
+        base::Optional<Statement*> body)
+      : Callable(Declarable::kMacro, name, signature, transitioning, body) {
     if (signature.parameter_types.var_args) {
       ReportError("Varargs are not supported for macros.");
     }
   }
 };
 
-class MacroList : public Declarable {
- public:
-  DECLARE_DECLARABLE_BOILERPLATE(MacroList, macro_list);
-  const std::vector<Macro*>& list() { return list_; }
-  Macro* AddMacro(Macro* macro) {
-    list_.emplace_back(macro);
-    return macro;
-  }
-
- private:
-  friend class Declarations;
-  MacroList() : Declarable(Declarable::kMacroList) {}
-
-  std::vector<Macro*> list_;
-};
-
 class Builtin : public Callable {
  public:
   enum Kind { kStub, kFixedArgsJavaScript, kVarArgsJavaScript };
@@ -211,19 +253,16 @@ class Builtin : public Callable {
   bool IsStub() const { return kind_ == kStub; }
   bool IsVarArgsJavaScript() const { return kind_ == kVarArgsJavaScript; }
   bool IsFixedArgsJavaScript() const { return kind_ == kFixedArgsJavaScript; }
-  bool IsExternal() const { return external_; }
 
  private:
   friend class Declarations;
-  Builtin(const std::string& name, Builtin::Kind kind, bool external,
+  Builtin(const std::string& name, Builtin::Kind kind,
           const Signature& signature, bool transitioning,
-          base::Optional<Generic*> generic)
-      : Callable(Declarable::kBuiltin, name, signature, transitioning, generic),
-        kind_(kind),
-        external_(external) {}
+          base::Optional<Statement*> body)
+      : Callable(Declarable::kBuiltin, name, signature, transitioning, body),
+        kind_(kind) {}
 
   Kind kind_;
-  bool external_;
 };
 
 class RuntimeFunction : public Callable {
@@ -233,9 +272,9 @@ class RuntimeFunction : public Callable {
  private:
   friend class Declarations;
   RuntimeFunction(const std::string& name, const Signature& signature,
-                  bool transitioning, base::Optional<Generic*> generic)
+                  bool transitioning)
       : Callable(Declarable::kRuntimeFunction, name, signature, transitioning,
-                 generic) {}
+                 base::nullopt) {}
 };
 
 class Generic : public Declarable {
@@ -243,53 +282,56 @@ class Generic : public Declarable {
   DECLARE_DECLARABLE_BOILERPLATE(Generic, generic);
 
   GenericDeclaration* declaration() const { return declaration_; }
+  const std::vector<std::string> generic_parameters() const {
+    return declaration()->generic_parameters;
+  }
   const std::string& name() const { return name_; }
-  Module* module() const { return module_; }
+  void AddSpecialization(const TypeVector& type_arguments,
+                         Callable* specialization) {
+    DCHECK_EQ(0, specializations_.count(type_arguments));
+    specializations_[type_arguments] = specialization;
+  }
+  base::Optional<Callable*> GetSpecialization(
+      const TypeVector& type_arguments) const {
+    auto it = specializations_.find(type_arguments);
+    if (it != specializations_.end()) return it->second;
+    return base::nullopt;
+  }
 
  private:
   friend class Declarations;
-  Generic(const std::string& name, Module* module,
-          GenericDeclaration* declaration)
+  Generic(const std::string& name, GenericDeclaration* declaration)
       : Declarable(Declarable::kGeneric),
         name_(name),
-        module_(module),
         declaration_(declaration) {}
 
   std::string name_;
-  Module* module_;
+  std::unordered_map<TypeVector, Callable*, base::hash<TypeVector>>
+      specializations_;
   GenericDeclaration* declaration_;
 };
 
-class GenericList : public Declarable {
- public:
-  DECLARE_DECLARABLE_BOILERPLATE(GenericList, generic_list);
-  const std::vector<Generic*>& list() { return list_; }
-  Generic* AddGeneric(Generic* generic) {
-    list_.push_back(generic);
-    return generic;
-  }
-
- private:
-  friend class Declarations;
-  GenericList() : Declarable(Declarable::kGenericList) {}
-
-  std::vector<Generic*> list_;
+struct SpecializationKey {
+  Generic* generic;
+  TypeVector specialized_types;
 };
 
-typedef std::pair<Generic*, TypeVector> SpecializationKey;
-
 class TypeAlias : public Declarable {
  public:
   DECLARE_DECLARABLE_BOILERPLATE(TypeAlias, type_alias);
 
   const Type* type() const { return type_; }
+  bool IsRedeclaration() const { return redeclaration_; }
 
  private:
   friend class Declarations;
-  explicit TypeAlias(const Type* type)
-      : Declarable(Declarable::kTypeAlias), type_(type) {}
+  explicit TypeAlias(const Type* type, bool redeclaration)
+      : Declarable(Declarable::kTypeAlias),
+        type_(type),
+        redeclaration_(redeclaration) {}
 
   const Type* type_;
+  bool redeclaration_;
 };
 
 std::ostream& operator<<(std::ostream& os, const Callable& m);

src/torque/declaration-visitor.cc

@@ -8,32 +8,6 @@ namespace v8 {
 namespace internal {
 namespace torque {
 
-void DeclarationVisitor::Visit(Expression* expr) {
-  CurrentSourcePosition::Scope scope(expr->pos);
-  switch (expr->kind) {
-#define ENUM_ITEM(name)        \
-  case AstNode::Kind::k##name: \
-    return Visit(name::cast(expr));
-    AST_EXPRESSION_NODE_KIND_LIST(ENUM_ITEM)
-#undef ENUM_ITEM
-    default:
-      UNIMPLEMENTED();
-  }
-}
-
-void DeclarationVisitor::Visit(Statement* stmt) {
-  CurrentSourcePosition::Scope scope(stmt->pos);
-  switch (stmt->kind) {
-#define ENUM_ITEM(name)        \
-  case AstNode::Kind::k##name: \
-    return Visit(name::cast(stmt));
-    AST_STATEMENT_NODE_KIND_LIST(ENUM_ITEM)
-#undef ENUM_ITEM
-    default:
-      UNIMPLEMENTED();
-  }
-}
-
 void DeclarationVisitor::Visit(Declaration* decl) {
   CurrentSourcePosition::Scope scope(decl->pos);
   switch (decl->kind) {
@@ -48,7 +22,7 @@ void DeclarationVisitor::Visit(Declaration* decl) {
 }
 
 void DeclarationVisitor::Visit(CallableNode* decl, const Signature& signature,
-                               Statement* body) {
+                               base::Optional<Statement*> body) {
   switch (decl->kind) {
 #define ENUM_ITEM(name)        \
   case AstNode::Kind::k##name: \
@@ -60,8 +34,10 @@ void DeclarationVisitor::Visit(CallableNode* decl, const Signature& signature,
   }
 }
 
-Builtin* DeclarationVisitor::BuiltinDeclarationCommon(
-    BuiltinDeclaration* decl, bool external, const Signature& signature) {
+Builtin* DeclarationVisitor::CreateBuiltin(BuiltinDeclaration* decl,
+                                           const std::string& external_name,
+                                           const Signature& signature,
+                                           base::Optional<Statement*> body) {
   const bool javascript = decl->javascript_linkage;
   const bool varargs = decl->signature->parameters.has_varargs;
   Builtin::Kind kind = !javascript ? Builtin::kStub
@@ -70,7 +46,7 @@ Builtin* DeclarationVisitor::BuiltinDeclarationCommon(
 
   if (signature.types().size() == 0 ||
       !(signature.types()[0] ==
-        declarations()->LookupGlobalType(CONTEXT_TYPE_STRING))) {
+        Declarations::LookupGlobalType(CONTEXT_TYPE_STRING))) {
     std::stringstream stream;
     stream << "first parameter to builtin " << decl->name
            << " is not a context but should be";
@@ -87,7 +63,7 @@ Builtin* DeclarationVisitor::BuiltinDeclarationCommon(
   if (javascript) {
     if (signature.types().size() < 2 ||
         !(signature.types()[1] ==
-          declarations()->LookupGlobalType(OBJECT_TYPE_STRING))) {
+          Declarations::LookupGlobalType(OBJECT_TYPE_STRING))) {
       std::stringstream stream;
       stream << "second parameter to javascript builtin " << decl->name
              << " is " << *signature.types()[1] << " but should be Object";
@@ -104,22 +80,21 @@ Builtin* DeclarationVisitor::BuiltinDeclarationCommon(
     ReportError(stream.str());
   }
 
-  std::string generated_name = GetGeneratedCallableName(
-      decl->name, declarations()->GetCurrentSpecializationTypeNamesVector());
-  return declarations()->DeclareBuiltin(generated_name, kind, external,
-                                        signature, decl->transitioning);
+  return Declarations::CreateBuiltin(external_name, kind, signature,
+                                     decl->transitioning, body);
 }
 
 void DeclarationVisitor::Visit(ExternalRuntimeDeclaration* decl,
-                               const Signature& signature, Statement* body) {
-  if (global_context_.verbose()) {
+                               const Signature& signature,
+                               base::Optional<Statement*> body) {
+  if (GlobalContext::verbose()) {
     std::cout << "found declaration of external runtime " << decl->name
               << " with signature ";
   }
 
   if (signature.parameter_types.types.size() == 0 ||
       !(signature.parameter_types.types[0] ==
-        declarations()->LookupGlobalType(CONTEXT_TYPE_STRING))) {
+        Declarations::LookupGlobalType(CONTEXT_TYPE_STRING))) {
     std::stringstream stream;
     stream << "first parameter to runtime " << decl->name
            << " is not a context but should be";
@@ -135,49 +110,39 @@ void DeclarationVisitor::Visit(ExternalRuntimeDeclaration* decl,
     ReportError(stream.str());
   }
 
-  declarations()->DeclareRuntimeFunction(decl->name, signature,
+  Declarations::DeclareRuntimeFunction(decl->name, signature,
                                        decl->transitioning);
 }
 
 void DeclarationVisitor::Visit(ExternalMacroDeclaration* decl,
-                               const Signature& signature, Statement* body) {
-  if (global_context_.verbose()) {
+                               const Signature& signature,
+                               base::Optional<Statement*> body) {
+  if (GlobalContext::verbose()) {
     std::cout << "found declaration of external macro " << decl->name
               << " with signature ";
   }
 
-  std::string generated_name = GetGeneratedCallableName(
-      decl->name, declarations()->GetCurrentSpecializationTypeNamesVector());
-  declarations()->DeclareMacro(generated_name, signature, decl->transitioning,
+  Declarations::DeclareMacro(decl->name, signature, decl->transitioning, body,
                              decl->op);
 }
 
 void DeclarationVisitor::Visit(TorqueBuiltinDeclaration* decl,
-                               const Signature& signature, Statement* body) {
-  Builtin* builtin = BuiltinDeclarationCommon(decl, false, signature);
-  CurrentCallableActivator activator(global_context_, builtin, decl);
-  torque_builtins_.push_back(builtin);
-  Visit(body);
+                               const Signature& signature,
+                               base::Optional<Statement*> body) {
+  Declarations::Declare(decl->name,
+                        CreateBuiltin(decl, decl->name, signature, body));
 }
 
 void DeclarationVisitor::Visit(TorqueMacroDeclaration* decl,
-                               const Signature& signature, Statement* body) {
-  std::string generated_name = GetGeneratedCallableName(
-      decl->name, declarations()->GetCurrentSpecializationTypeNamesVector());
-  Macro* macro = declarations()->DeclareMacro(generated_name, signature,
-                                              decl->transitioning, decl->op);
-
-  CurrentCallableActivator activator(global_context_, macro, decl);
-
-  if (body != nullptr) {
-    Visit(body);
-  }
+                               const Signature& signature,
+                               base::Optional<Statement*> body) {
+  Declarations::DeclareMacro(decl->name, signature, decl->transitioning, body,
+                             decl->op);
 }
 
 void DeclarationVisitor::Visit(ConstDeclaration* decl) {
-  declarations()->DeclareModuleConstant(decl->name,
-                                        declarations()->GetType(decl->type));
-  Visit(decl->expression);
+  Declarations::DeclareModuleConstant(
+      decl->name, Declarations::GetType(decl->type), decl->expression);
 }
 
 void DeclarationVisitor::Visit(StandardDeclaration* decl) {
@@ -186,7 +151,7 @@ void DeclarationVisitor::Visit(StandardDeclaration* decl) {
 }
 
 void DeclarationVisitor::Visit(GenericDeclaration* decl) {
-  declarations()->DeclareGeneric(decl->callable->name, CurrentModule(), decl);
+  Declarations::DeclareGeneric(decl->callable->name, decl);
 }
 
 void DeclarationVisitor::Visit(SpecializationDeclaration* decl) {
@@ -197,40 +162,30 @@ void DeclarationVisitor::Visit(SpecializationDeclaration* decl) {
     ReportError(stream.str());
   }
 
-  GenericList* generic_list = declarations()->LookupGeneric(decl->name);
+  std::vector<Generic*> generic_list = Declarations::LookupGeneric(decl->name);
   // Find the matching generic specialization based on the concrete parameter
   // list.
-  CallableNode* matching_callable = nullptr;
-  SpecializationKey matching_key;
+  Generic* matching_generic = nullptr;
   Signature signature_with_types = MakeSignature(decl->signature.get());
-  for (Generic* generic : generic_list->list()) {
-    SpecializationKey key = {generic, GetTypeVector(decl->generic_parameters)};
-    CallableNode* callable_candidate = generic->declaration()->callable;
-    // Abuse the Specialization nodes' scope to temporarily declare the
-    // specialization aliases for the generic types to compare signatures. This
-    // scope is never used for anything else, so it's OK to pollute it.
-    Declarations::CleanNodeScopeActivator specialization_activator(
-        declarations(), decl);
-    DeclareSpecializedTypes(key);
-    Signature generic_signature_with_types =
-        MakeSignature(generic->declaration()->callable->signature.get());
+  for (Generic* generic : generic_list) {
+    Signature generic_signature_with_types = MakeSpecializedSignature(
+        SpecializationKey{generic, GetTypeVector(decl->generic_parameters)});
     if (signature_with_types.HasSameTypesAs(generic_signature_with_types,
                                             ParameterMode::kIgnoreImplicit)) {
-      if (matching_callable != nullptr) {
+      if (matching_generic != nullptr) {
         std::stringstream stream;
-        stream << "specialization of " << callable_candidate->name
+        stream << "specialization of " << decl->name
                << " is ambigous, it matches more than one generic declaration ("
-               << *matching_key.first << " and " << *key.first << ")";
+               << *matching_generic << " and " << *generic << ")";
         ReportError(stream.str());
       }
-      matching_callable = callable_candidate;
-      matching_key = key;
+      matching_generic = generic;
     }
   }
 
-  if (matching_callable == nullptr) {
+  if (matching_generic == nullptr) {
     std::stringstream stream;
-    if (generic_list->list().size() == 0) {
+    if (generic_list.size() == 0) {
       stream << "no generic defined with the name " << decl->name;
       ReportError(stream.str());
     }
@@ -239,46 +194,22 @@ void DeclarationVisitor::Visit(SpecializationDeclaration* decl) {
     stream << "specialization signature:";
     stream << "\n  " << signature_with_types;
     stream << "\ncandidates are:";
-    for (Generic* generic : generic_list->list()) {
-      SpecializationKey key = {generic,
-                               GetTypeVector(decl->generic_parameters)};
-      Declarations::CleanNodeScopeActivator specialization_activator(
-          declarations(), decl);
-      DeclareSpecializedTypes(key);
-      Signature generic_signature_with_types =
-          MakeSignature(generic->declaration()->callable->signature.get());
-      stream << "\n  " << generic_signature_with_types;
+    for (Generic* generic : generic_list) {
+      stream << "\n  "
+             << MakeSpecializedSignature(SpecializationKey{
+                    generic, GetTypeVector(decl->generic_parameters)});
     }
     ReportError(stream.str());
   }
 
-  // Make sure the declarations of the parameter types for the specialization
-  // are the ones from the matching generic.
-  {
-    Declarations::CleanNodeScopeActivator specialization_activator(
-        declarations(), decl);
-    DeclareSpecializedTypes(matching_key);
-  }
-
-  SpecializeGeneric({matching_key, matching_callable, decl->signature.get(),
-                     decl->body, decl->pos});
-}
-
-void DeclarationVisitor::Visit(ReturnStatement* stmt) {
-  if (stmt->value) {
-    Visit(*stmt->value);
-  }
-}
-
-void DeclarationVisitor::Visit(VarDeclarationStatement* stmt) {
-  std::string variable_name = stmt->name;
-  if (stmt->initializer) {
-    Visit(*stmt->initializer);
-  }
+  Specialize(SpecializationKey{matching_generic,
+                               GetTypeVector(decl->generic_parameters)},
+             matching_generic->declaration()->callable, decl->signature.get(),
+             decl->body);
 }
 
 void DeclarationVisitor::Visit(ExternConstDeclaration* decl) {
-  const Type* type = declarations()->GetType(decl->type);
+  const Type* type = Declarations::GetType(decl->type);
   if (!type->IsConstexpr()) {
     std::stringstream stream;
     stream << "extern constants must have constexpr type, but found: \""
@@ -286,149 +217,21 @@ void DeclarationVisitor::Visit(ExternConstDeclaration* decl) {
     ReportError(stream.str());
   }
 
-  declarations()->DeclareExternConstant(decl->name, type, decl->literal);
+  Declarations::DeclareExternConstant(decl->name, type, decl->literal);
 }
 
 void DeclarationVisitor::Visit(StructDeclaration* decl) {
   std::vector<NameAndType> fields;
   for (auto& field : decl->fields) {
-    const Type* field_type = declarations()->GetType(field.type);
+    const Type* field_type = Declarations::GetType(field.type);
     fields.push_back({field.name, field_type});
   }
-  declarations()->DeclareStruct(CurrentModule(), decl->name, fields);
-}
-
-void DeclarationVisitor::Visit(LogicalOrExpression* expr) {
-    Visit(expr->left);
-  Visit(expr->right);
-}
-
-void DeclarationVisitor::Visit(LogicalAndExpression* expr) {
-    Visit(expr->left);
-  Visit(expr->right);
-}
-
-void DeclarationVisitor::Visit(ConditionalExpression* expr) {
-  Visit(expr->condition);
-  Visit(expr->if_true);
-  Visit(expr->if_false);
-}
-
-void DeclarationVisitor::Visit(IfStatement* stmt) {
-  Visit(stmt->condition);
-  Visit(stmt->if_true);
-  if (stmt->if_false) Visit(*stmt->if_false);
-}
-
-void DeclarationVisitor::Visit(WhileStatement* stmt) {
-  Visit(stmt->condition);
-  Visit(stmt->body);
-}
-
-void DeclarationVisitor::Visit(ForOfLoopStatement* stmt) {
-  // Scope for for iteration variable
-  Declarations::NodeScopeActivator scope(declarations(), stmt);
-  Visit(stmt->var_declaration);
-  Visit(stmt->iterable);
-  if (stmt->begin) Visit(*stmt->begin);
-  if (stmt->end) Visit(*stmt->end);
-  Visit(stmt->body);
-}
-
-void DeclarationVisitor::Visit(ForLoopStatement* stmt) {
-  if (stmt->var_declaration) Visit(*stmt->var_declaration);
-  if (stmt->test) Visit(*stmt->test);
-  Visit(stmt->body);
-  if (stmt->action) Visit(*stmt->action);
-}
-
-void DeclarationVisitor::Visit(TryLabelExpression* stmt) {
-  Visit(stmt->try_expression);
-  Visit(stmt->label_block->body);
-}
-
-void DeclarationVisitor::GenerateHeader(std::string& file_name) {
-  std::stringstream new_contents_stream;
-  new_contents_stream
-      << "#ifndef V8_BUILTINS_BUILTIN_DEFINITIONS_FROM_DSL_H_\n"
-         "#define V8_BUILTINS_BUILTIN_DEFINITIONS_FROM_DSL_H_\n"
-         "\n"
-         "#define BUILTIN_LIST_FROM_DSL(CPP, API, TFJ, TFC, TFS, TFH, ASM) "
-         "\\\n";
-  for (auto builtin : torque_builtins_) {
-    int firstParameterIndex = 1;
-    bool declareParameters = true;
-    if (builtin->IsStub()) {
-      new_contents_stream << "TFS(" << builtin->name();
-    } else {
-      new_contents_stream << "TFJ(" << builtin->name();
-      if (builtin->IsVarArgsJavaScript()) {
-        new_contents_stream
-            << ", SharedFunctionInfo::kDontAdaptArgumentsSentinel";
-        declareParameters = false;
-      } else {
-        assert(builtin->IsFixedArgsJavaScript());
-        // FixedArg javascript builtins need to offer the parameter
-        // count.
-        assert(builtin->parameter_names().size() >= 2);
-        new_contents_stream << ", " << (builtin->parameter_names().size() - 2);
-        // And the receiver is explicitly declared.
-        new_contents_stream << ", kReceiver";
-        firstParameterIndex = 2;
-      }
-    }
-    if (declareParameters) {
-      int index = 0;
-      for (const auto& parameter : builtin->parameter_names()) {
-        if (index >= firstParameterIndex) {
-          new_contents_stream << ", k" << CamelifyString(parameter);
-        }
-        index++;
-      }
-    }
-    new_contents_stream << ") \\\n";
-  }
-  new_contents_stream
-      << "\n"
-         "#endif  // V8_BUILTINS_BUILTIN_DEFINITIONS_FROM_DSL_H_\n";
-
-  std::string new_contents(new_contents_stream.str());
-  ReplaceFileContentsIfDifferent(file_name, new_contents);
-}
-
-void DeclarationVisitor::Visit(IdentifierExpression* expr) {
-  if (expr->generic_arguments.size() != 0) {
-    TypeVector specialization_types;
-    for (auto t : expr->generic_arguments) {
-      specialization_types.push_back(declarations()->GetType(t));
-    }
-    // Specialize all versions of the generic, since the exact parameter type
-    // list cannot be resolved until the call's parameter expressions are
-    // evaluated. This is an overly conservative but simple way to make sure
-    // that the correct specialization exists.
-    for (auto generic : declarations()->LookupGeneric(expr->name)->list()) {
-      CallableNode* callable = generic->declaration()->callable;
-      if (generic->declaration()->body) {
-        QueueGenericSpecialization({generic, specialization_types}, callable,
-                                   callable->signature.get(),
-                                   generic->declaration()->body);
-      }
-    }
-  }
-}
-
-void DeclarationVisitor::Visit(StatementExpression* expr) {
-  Visit(expr->statement);
-}
-
-void DeclarationVisitor::Visit(CallExpression* expr) {
-  Visit(&expr->callee);
-  for (Expression* arg : expr->arguments) Visit(arg);
+  Declarations::DeclareStruct(decl->name, fields);
 }
 
 void DeclarationVisitor::Visit(TypeDeclaration* decl) {
   std::string generates = decl->generates ? *decl->generates : std::string("");
-  const AbstractType* type = declarations()->DeclareAbstractType(
+  const AbstractType* type = Declarations::DeclareAbstractType(
       decl->name, decl->transient, generates, {}, decl->extends);
 
   if (decl->constexpr_generates) {
@@ -439,7 +242,7 @@ void DeclarationVisitor::Visit(TypeDeclaration* decl) {
     base::Optional<std::string> constexpr_extends;
     if (decl->extends)
       constexpr_extends = CONSTEXPR_TYPE_PREFIX + *decl->extends;
-    declarations()->DeclareAbstractType(constexpr_name, false,
+    Declarations::DeclareAbstractType(constexpr_name, false,
                                       *decl->constexpr_generates, type,
                                       constexpr_extends);
   }
@@ -447,55 +250,86 @@ void DeclarationVisitor::Visit(TypeDeclaration* decl) {
 
 void DeclarationVisitor::DeclareSpecializedTypes(const SpecializationKey& key) {
   size_t i = 0;
-  Generic* generic = key.first;
   const std::size_t generic_parameter_count =
-      generic->declaration()->generic_parameters.size();
-  if (generic_parameter_count != key.second.size()) {
+      key.generic->declaration()->generic_parameters.size();
+  if (generic_parameter_count != key.specialized_types.size()) {
     std::stringstream stream;
     stream << "Wrong generic argument count for specialization of \""
-           << generic->name() << "\", expected: " << generic_parameter_count
-           << ", actual: " << key.second.size();
+           << key.generic->name() << "\", expected: " << generic_parameter_count
+           << ", actual: " << key.specialized_types.size();
     ReportError(stream.str());
   }
 
-  for (auto type : key.second) {
+  for (auto type : key.specialized_types) {
     std::string generic_type_name =
-        generic->declaration()->generic_parameters[i++];
-    declarations()->DeclareType(generic_type_name, type);
+        key.generic->declaration()->generic_parameters[i++];
+    Declarations::DeclareType(generic_type_name, type, true);
   }
 }
 
-void DeclarationVisitor::Specialize(const SpecializationKey& key,
-                                    CallableNode* callable,
-                                    const CallableNodeSignature* signature,
-                                    Statement* body) {
-  Generic* generic = key.first;
+Signature DeclarationVisitor::MakeSpecializedSignature(
+    const SpecializationKey& key) {
+  CurrentScope::Scope generic_scope(key.generic->ParentScope());
+  // Create a temporary fake-module just to temporarily declare the
+  // specialization aliases for the generic types to create a signature.
+  Module tmp_module("_tmp");
+  CurrentScope::Scope tmp_module_scope(&tmp_module);
+  DeclareSpecializedTypes(key);
+  return MakeSignature(key.generic->declaration()->callable->signature.get());
+}
 
+Callable* DeclarationVisitor::SpecializeImplicit(const SpecializationKey& key) {
+  if (!key.generic->declaration()->body) {
+    ReportError("missing specialization of ", key.generic->name(),
+                " with types <", key.specialized_types, "> declared at ",
+                key.generic->pos());
+  }
+  CurrentScope::Scope generic_scope(key.generic->ParentScope());
+  Callable* result =
+      Specialize(key, key.generic->declaration()->callable, base::nullopt,
+                 *key.generic->declaration()->body);
+  CurrentScope::Scope callable_scope(result);
+  DeclareSpecializedTypes(key);
+  return result;
+}
+
+Callable* DeclarationVisitor::Specialize(
+    const SpecializationKey& key, CallableNode* declaration,
+    base::Optional<const CallableNodeSignature*> signature, Statement* body) {
   // TODO(tebbi): The error should point to the source position where the
   // instantiation was requested.
-  CurrentSourcePosition::Scope pos_scope(generic->declaration()->pos);
+  CurrentSourcePosition::Scope pos_scope(key.generic->declaration()->pos);
   size_t generic_parameter_count =
-      generic->declaration()->generic_parameters.size();
-  if (generic_parameter_count != key.second.size()) {
+      key.generic->declaration()->generic_parameters.size();
+  if (generic_parameter_count != key.specialized_types.size()) {
     std::stringstream stream;
     stream << "number of template parameters ("
-           << std::to_string(key.second.size())
-           << ") to intantiation of generic " << callable->name
+           << std::to_string(key.specialized_types.size())
+           << ") to intantiation of generic " << declaration->name
            << " doesnt match the generic's declaration ("
            << std::to_string(generic_parameter_count) << ")";
     ReportError(stream.str());
   }
-
-  Signature type_signature;
-  {
-    // Manually activate the specialized generic's scope when declaring the
-    // generic parameter specializations.
-    Declarations::GenericScopeActivator namespace_scope(declarations(), key);
-    DeclareSpecializedTypes(key);
-    type_signature = MakeSignature(signature);
+  if (key.generic->GetSpecialization(key.specialized_types)) {
+    ReportError("cannot redeclare specialization of ", key.generic->name(),
+                " with types <", key.specialized_types, ">");
   }
 
-  Visit(callable, type_signature, body);
+  Signature type_signature =
+      signature ? MakeSignature(*signature) : MakeSpecializedSignature(key);
+
+  std::string generated_name = Declarations::GetGeneratedCallableName(
+      declaration->name, key.specialized_types);
+  Callable* callable;
+  if (MacroDeclaration::DynamicCast(declaration) != nullptr) {
+    callable = Declarations::CreateMacro(generated_name, type_signature,
+                                         declaration->transitioning, body);
+  } else {
+    BuiltinDeclaration* builtin = BuiltinDeclaration::cast(declaration);
+    callable = CreateBuiltin(builtin, generated_name, type_signature, body);
+  }
+  key.generic->AddSpecialization(key.specialized_types, callable);
+  return callable;
 }
 
 }  // namespace torque

src/torque/declaration-visitor.h

@@ -12,7 +12,6 @@
 #include "src/torque/declarations.h"
 #include "src/torque/file-visitor.h"
 #include "src/torque/global-context.h"
-#include "src/torque/scope.h"
 #include "src/torque/types.h"
 #include "src/torque/utils.h"
 
@@ -22,132 +21,73 @@ namespace torque {
 
 class DeclarationVisitor : public FileVisitor {
  public:
-  explicit DeclarationVisitor(GlobalContext& global_context)
-      : FileVisitor(global_context),
-        scope_(declarations(), global_context.GetDefaultModule()) {}
-
   void Visit(Ast* ast) {
-    Visit(ast->default_module());
-    DrainSpecializationQueue();
+    CurrentScope::Scope current_namespace(GlobalContext::GetDefaultModule());
+    for (Declaration* child : ast->declarations()) Visit(child);
   }
 
-  void Visit(Expression* expr);
-  void Visit(Statement* stmt);
   void Visit(Declaration* decl);
 
-  void Visit(ModuleDeclaration* decl) {
-    ScopedModuleActivator activator(this, decl->GetModule());
-    Declarations::ModuleScopeActivator scope(declarations(), decl->GetModule());
-    for (Declaration* child : decl->declarations) Visit(child);
+  Module* GetOrCreateModule(const std::string& name) {
+    std::vector<Module*> existing_modules =
+        FilterDeclarables<Module>(Declarations::TryLookupShallow(name));
+    if (existing_modules.empty()) {
+      return Declarations::DeclareModule(name);
     }
-  void Visit(DefaultModuleDeclaration* decl) {
-    decl->SetModule(global_context_.GetDefaultModule());
-    Visit(implicit_cast<ModuleDeclaration*>(decl));
-  }
-  void Visit(ExplicitModuleDeclaration* decl) {
-    decl->SetModule(global_context_.GetModule(decl->name));
-    Visit(implicit_cast<ModuleDeclaration*>(decl));
+    DCHECK_EQ(1, existing_modules.size());
+    return existing_modules.front();
   }
 
-  void Visit(IdentifierExpression* expr);
-  void Visit(NumberLiteralExpression* expr) {}
-  void Visit(StringLiteralExpression* expr) {}
-  void Visit(CallExpression* expr);
-  void Visit(ElementAccessExpression* expr) {
-    Visit(expr->array);
-    Visit(expr->index);
-  }
-  void Visit(FieldAccessExpression* expr) { Visit(expr->object); }
-  void Visit(BlockStatement* expr) {
-    Declarations::NodeScopeActivator scope(declarations(), expr);
-    for (Statement* stmt : expr->statements) Visit(stmt);
+  void Visit(ModuleDeclaration* decl) {
+    CurrentScope::Scope current_scope(GetOrCreateModule(decl->name));
+    for (Declaration* child : decl->declarations) Visit(child);
   }
-  void Visit(ExpressionStatement* stmt) { Visit(stmt->expression); }
-  void Visit(TailCallStatement* stmt) { Visit(stmt->call); }
+
   void Visit(TypeDeclaration* decl);
 
   void Visit(TypeAliasDeclaration* decl) {
-    const Type* type = declarations()->GetType(decl->type);
+    const Type* type = Declarations::GetType(decl->type);
     type->AddAlias(decl->name);
-    declarations()->DeclareType(decl->name, type);
+    Declarations::DeclareType(decl->name, type, true);
   }
 
-  Builtin* BuiltinDeclarationCommon(BuiltinDeclaration* decl, bool external,
-                                    const Signature& signature);
-
+  Builtin* CreateBuiltin(BuiltinDeclaration* decl,
+                         const std::string& external_name,
+                         const Signature& signature,
+                         base::Optional<Statement*> body);
   void Visit(ExternalBuiltinDeclaration* decl, const Signature& signature,
-             Statement* body) {
-    BuiltinDeclarationCommon(decl, true, signature);
+             base::Optional<Statement*> body) {
+    Declarations::Declare(
+        decl->name, CreateBuiltin(decl, decl->name, signature, base::nullopt));
   }
 
   void Visit(ExternalRuntimeDeclaration* decl, const Signature& sig,
-             Statement* body);
+             base::Optional<Statement*> body);
   void Visit(ExternalMacroDeclaration* decl, const Signature& sig,
-             Statement* body);
+             base::Optional<Statement*> body);
   void Visit(TorqueBuiltinDeclaration* decl, const Signature& signature,
-             Statement* body);
+             base::Optional<Statement*> body);
   void Visit(TorqueMacroDeclaration* decl, const Signature& signature,
-             Statement* body);
+             base::Optional<Statement*> body);
 
-  void Visit(CallableNode* decl, const Signature& signature, Statement* body);
+  void Visit(CallableNode* decl, const Signature& signature,
+             base::Optional<Statement*> body);
 
   void Visit(ConstDeclaration* decl);
   void Visit(StandardDeclaration* decl);
   void Visit(GenericDeclaration* decl);
   void Visit(SpecializationDeclaration* decl);
-  void Visit(ReturnStatement* stmt);
-
-  void Visit(DebugStatement* stmt) {}
-  void Visit(AssertStatement* stmt) {
-    bool do_check = !stmt->debug_only;
-#if defined(DEBUG)
-    do_check = true;
-#endif
-    if (do_check) Visit(stmt->expression);
-  }
-
-  void Visit(VarDeclarationStatement* stmt);
   void Visit(ExternConstDeclaration* decl);
-
   void Visit(StructDeclaration* decl);
-  void Visit(StructExpression* decl) {}
-
-  void Visit(LogicalOrExpression* expr);
-  void Visit(LogicalAndExpression* expr);
-  void Visit(ConditionalExpression* expr);
-  void Visit(IfStatement* stmt);
-  void Visit(WhileStatement* stmt);
-  void Visit(ForOfLoopStatement* stmt);
-
-  void Visit(AssignmentExpression* expr) {
-    Visit(expr->location);
-    Visit(expr->value);
-  }
-
-  void Visit(BreakStatement* stmt) {}
-  void Visit(ContinueStatement* stmt) {}
-  void Visit(GotoStatement* expr) {}
-  void Visit(ForLoopStatement* stmt);
 
-  void Visit(IncrementDecrementExpression* expr) {
-    Visit(expr->location);
-  }
-
-  void Visit(AssumeTypeImpossibleExpression* expr) { Visit(expr->expression); }
-
-  void Visit(TryLabelExpression* stmt);
-  void Visit(StatementExpression* stmt);
-  void GenerateHeader(std::string& file_name);
+  Signature MakeSpecializedSignature(const SpecializationKey& key);
+  Callable* SpecializeImplicit(const SpecializationKey& key);
+  Callable* Specialize(const SpecializationKey& key, CallableNode* declaration,
+                       base::Optional<const CallableNodeSignature*> signature,
+                       Statement* body);
 
  private:
   void DeclareSpecializedTypes(const SpecializationKey& key);
-
-  void Specialize(const SpecializationKey& key, CallableNode* callable,
-                  const CallableNodeSignature* signature,
-                  Statement* body) override;
-
-  Declarations::ModuleScopeActivator scope_;
-  std::vector<Builtin*> torque_builtins_;
 };
 
 }  // namespace torque

src/torque/declarations.cc

@@ -4,77 +4,71 @@
 
 #include "src/torque/declarations.h"
 #include "src/torque/declarable.h"
+#include "src/torque/global-context.h"
 #include "src/torque/type-oracle.h"
 
 namespace v8 {
 namespace internal {
 namespace torque {
 
-Scope* Declarations::GetModuleScope(const Module* module) {
-  auto i = module_scopes_.find(module);
-  if (i != module_scopes_.end()) return i->second;
-  Scope* result = chain_.NewScope();
-  module_scopes_[module] = result;
-  return result;
-}
+DEFINE_CONTEXTUAL_VARIABLE(GlobalContext)
+
+namespace {
 
-Scope* Declarations::GetNodeScope(const AstNode* node, bool reset_scope) {
-  std::pair<const AstNode*, TypeVector> key(
-      node, current_generic_specialization_ == nullptr
-                ? TypeVector()
-                : current_generic_specialization_->second);
-  if (!reset_scope) {
-    auto i = scopes_.find(key);
-    if (i != scopes_.end()) return i->second;
+template <class T>
+std::vector<T> EnsureNonempty(std::vector<T> list, const std::string& name,
+                              const char* kind) {
+  if (list.empty()) {
+    ReportError("there is no ", kind, "named ", name);
   }
-  Scope* result = chain_.NewScope();
-  scopes_[key] = result;
-  return result;
+  return std::move(list);
 }
 
-Scope* Declarations::GetGenericScope(Generic* generic,
-                                     const TypeVector& types) {
-  std::pair<const AstNode*, TypeVector> key(generic->declaration()->callable,
-                                            types);
-  auto i = scopes_.find(key);
-  if (i != scopes_.end()) return i->second;
-  Scope* result = chain_.NewScope();
-  scopes_[key] = result;
-  return result;
+template <class T>
+T EnsureUnique(const std::vector<T>& list, const std::string& name,
+               const char* kind) {
+  if (list.empty()) {
+    ReportError("there is no ", kind, "named ", name);
+  }
+  if (list.size() >= 2) {
+    ReportError("ambiguous reference to ", kind, " ", name);
+  }
+  return list.front();
 }
 
-bool Declarations::IsDeclaredInCurrentScope(const std::string& name) {
-  return chain_.ShallowLookup(name) != nullptr;
+template <class T>
+void CheckAlreadyDeclared(const std::string& name, const char* new_type) {
+  std::vector<T*> declarations =
+      FilterDeclarables<T>(Declarations::TryLookupShallow(name));
+  if (!declarations.empty()) {
+    Scope* scope = CurrentScope::Get();
+    ReportError("cannot redeclare ", name, " (type ", new_type, scope, ")");
+  }
 }
 
-void Declarations::CheckAlreadyDeclared(const std::string& name,
-                                        const char* new_type) {
-  if (IsDeclaredInCurrentScope(name)) {
+}  // namespace
+
+std::vector<Declarable*> Declarations::LookupGlobalScope(
+    const std::string& name) {
+  std::vector<Declarable*> d = GlobalContext::GetDefaultModule()->Lookup(name);
+  if (d.empty()) {
     std::stringstream s;
-    s << "cannot redeclare " << name << " (type " << new_type << ")";
+    s << "cannot find \"" << name << "\" in global scope";
     ReportError(s.str());
   }
+  return d;
 }
 
 const Type* Declarations::LookupType(const std::string& name) {
-  Declarable* raw = Lookup(name);
-  if (raw->IsTypeAlias()) {
-    return TypeAlias::cast(raw)->type();
-  }
-  std::stringstream s;
-  s << "declaration \"" << name << "\" is not a Type";
-  ReportError(s.str());
-  return nullptr;
+  TypeAlias* declaration =
+      EnsureUnique(FilterDeclarables<TypeAlias>(Lookup(name)), name, "type");
+  return declaration->type();
 }
 
 const Type* Declarations::LookupGlobalType(const std::string& name) {
-  Declarable* raw = LookupGlobalScope(name);
-  if (!raw->IsTypeAlias()) {
-    std::stringstream s;
-    s << "declaration \"" << name << "\" is not a Type";
-    ReportError(s.str());
-  }
-  return TypeAlias::cast(raw)->type();
+  TypeAlias* declaration = EnsureUnique(
+      FilterDeclarables<TypeAlias>(LookupGlobalScope(name)), name, "type");
+  return declaration->type();
 }
 
 const Type* Declarations::GetType(TypeExpression* type_expression) {
@@ -98,7 +92,7 @@ const Type* Declarations::GetType(TypeExpression* type_expression) {
 
 Builtin* Declarations::FindSomeInternalBuiltinWithType(
     const FunctionPointerType* type) {
-  for (auto& declarable : declarables_) {
+  for (auto& declarable : GlobalContext::AllDeclarables()) {
     if (Builtin* builtin = Builtin::DynamicCast(declarable.get())) {
       if (!builtin->IsExternal() && builtin->kind() == Builtin::kStub &&
           builtin->signature().return_type == type->return_type() &&
@@ -112,231 +106,147 @@ Builtin* Declarations::FindSomeInternalBuiltinWithType(
 }
 
 Value* Declarations::LookupValue(const std::string& name) {
-  Declarable* d = Lookup(name);
-  if (!d->IsValue()) {
-    std::stringstream s;
-    s << "declaration \"" << name << "\" is not a Value";
-    ReportError(s.str());
-  }
-  return Value::cast(d);
+  return EnsureUnique(FilterDeclarables<Value>(Lookup(name)), name, "value");
 }
 
 Macro* Declarations::TryLookupMacro(const std::string& name,
                                     const TypeVector& types) {
-  Declarable* declarable = TryLookup(name);
-  if (declarable != nullptr) {
-    if (declarable->IsMacroList()) {
-      for (auto& m : MacroList::cast(declarable)->list()) {
+  std::vector<Macro*> macros = TryLookup<Macro>(name);
+  for (auto& m : macros) {
     auto signature_types = m->signature().GetExplicitTypes();
-        if (signature_types == types &&
-            !m->signature().parameter_types.var_args) {
+    if (signature_types == types && !m->signature().parameter_types.var_args) {
       return m;
     }
   }
-    }
-  }
   return nullptr;
 }
 
-Macro* Declarations::LookupMacro(const std::string& name,
-                                 const TypeVector& types) {
-  Macro* result = TryLookupMacro(name, types);
-  if (result != nullptr) return result;
-  std::stringstream stream;
-  stream << "macro " << name << " with parameter types " << types
-         << " is not defined";
-  ReportError(stream.str());
-  return nullptr;
+base::Optional<Builtin*> Declarations::TryLookupBuiltin(
+    const std::string& name) {
+  std::vector<Builtin*> builtins = TryLookup<Builtin>(name);
+  if (builtins.empty()) return base::nullopt;
+  return EnsureUnique(builtins, name, "builtin");
 }
 
-Builtin* Declarations::LookupBuiltin(const std::string& name) {
-  Declarable* declarable = Lookup(name);
-  if (declarable != nullptr) {
-    if (declarable->IsBuiltin()) {
-      return Builtin::cast(declarable);
-    }
-    ReportError(name + " is not a builtin");
-  }
-  ReportError(std::string("builtin ") + name + " is not defined");
-  return nullptr;
+std::vector<Generic*> Declarations::LookupGeneric(const std::string& name) {
+  return EnsureNonempty(FilterDeclarables<Generic>(Lookup(name)), name,
+                        "generic");
 }
 
-GenericList* Declarations::LookupGeneric(const std::string& name) {
-  Declarable* declarable_list = Lookup(name);
-  if (declarable_list != nullptr) {
-    if (declarable_list->IsGenericList()) {
-      return GenericList::cast(declarable_list);
-    }
-    ReportError(name + " is not a generic");
-  }
-  ReportError(std::string("generic ") + name + " is not defined");
-  return nullptr;
+Generic* Declarations::LookupUniqueGeneric(const std::string& name) {
+  return EnsureUnique(FilterDeclarables<Generic>(Lookup(name)), name,
+                      "generic");
 }
 
-ModuleConstant* Declarations::LookupModuleConstant(const std::string& name) {
-  Declarable* declarable = Lookup(name);
-  if (declarable != nullptr) {
-    if (declarable->IsModuleConstant()) {
-      return ModuleConstant::cast(declarable);
-    }
-    ReportError(name + " is not a constant");
-  }
-  ReportError(std::string("constant \"") + name + "\" is not defined");
-  return nullptr;
+Module* Declarations::DeclareModule(const std::string& name) {
+  return Declare(name, std::unique_ptr<Module>(new Module(name)));
 }
 
 const AbstractType* Declarations::DeclareAbstractType(
     const std::string& name, bool transient, const std::string& generated,
     base::Optional<const AbstractType*> non_constexpr_version,
     const base::Optional<std::string>& parent) {
-  CheckAlreadyDeclared(name, "type");
+  CheckAlreadyDeclared<TypeAlias>(name, "type");
   const Type* parent_type = nullptr;
   if (parent) {
-    Declarable* maybe_parent_type = Lookup(*parent);
-    if (maybe_parent_type == nullptr) {
-      std::stringstream s;
-      s << "cannot find parent type \"" << *parent << "\"";
-      ReportError(s.str());
-    }
-    if (!maybe_parent_type->IsTypeAlias()) {
-      std::stringstream s;
-      s << "parent \"" << *parent << "\" of type \"" << name << "\""
-        << " is not a type";
-      ReportError(s.str());
-    }
-    parent_type = TypeAlias::cast(maybe_parent_type)->type();
+    parent_type = LookupType(*parent);
   }
   const AbstractType* type = TypeOracle::GetAbstractType(
       parent_type, name, transient, generated, non_constexpr_version);
-  DeclareType(name, type);
+  DeclareType(name, type, false);
   return type;
 }
 
-void Declarations::DeclareType(const std::string& name, const Type* type) {
-  CheckAlreadyDeclared(name, "type");
-  TypeAlias* result = new TypeAlias(type);
-  Declare(name, std::unique_ptr<TypeAlias>(result));
+void Declarations::DeclareType(const std::string& name, const Type* type,
+                               bool redeclaration) {
+  CheckAlreadyDeclared<TypeAlias>(name, "type");
+  Declare(name, std::unique_ptr<TypeAlias>(new TypeAlias(type, redeclaration)));
 }
 
-void Declarations::DeclareStruct(Module* module, const std::string& name,
+void Declarations::DeclareStruct(const std::string& name,
                                  const std::vector<NameAndType>& fields) {
-  const StructType* new_type = TypeOracle::GetStructType(module, name, fields);
-  DeclareType(name, new_type);
+  const StructType* new_type = TypeOracle::GetStructType(name, fields);
+  DeclareType(name, new_type, false);
 }
 
-MacroList* Declarations::GetMacroListForName(const std::string& name,
-                                             const Signature& signature) {
-  auto previous = chain_.Lookup(name);
-  MacroList* macro_list = nullptr;
-  if (previous == nullptr) {
-    macro_list = new MacroList();
-    Declare(name, std::unique_ptr<Declarable>(macro_list));
-  } else if (!previous->IsMacroList()) {
-    std::stringstream s;
-    s << "cannot redeclare non-macro " << name << " as a macro";
-    ReportError(s.str());
-  } else {
-    macro_list = MacroList::cast(previous);
-  }
-  for (auto& macro : macro_list->list()) {
-    if (signature.parameter_types.types ==
-            macro->signature().parameter_types.types &&
-        signature.parameter_types.var_args ==
-            macro->signature().parameter_types.var_args) {
-      std::stringstream s;
-      s << "cannot redeclare " << name
-        << " as a macro with identical parameter list "
-        << signature.parameter_types;
-      ReportError(s.str());
-    }
-  }
-  return macro_list;
+Macro* Declarations::CreateMacro(const std::string& name,
+                                 const Signature& signature, bool transitioning,
+                                 base::Optional<Statement*> body) {
+  return RegisterDeclarable(
+      std::unique_ptr<Macro>(new Macro(name, signature, transitioning, body)));
 }
 
 Macro* Declarations::DeclareMacro(const std::string& name,
                                   const Signature& signature,
                                   bool transitioning,
+                                  base::Optional<Statement*> body,
                                   base::Optional<std::string> op) {
-  Macro* macro = RegisterDeclarable(std::unique_ptr<Macro>(
-      new Macro(name, signature, transitioning, GetCurrentGeneric())));
-  GetMacroListForName(name, signature)->AddMacro(macro);
-  if (op) GetMacroListForName(*op, signature)->AddMacro(macro);
+  if (TryLookupMacro(name, signature.GetExplicitTypes())) {
+    ReportError("cannot redeclare macro ", name,
+                " with identical explicit parameters");
+  }
+  Macro* macro = CreateMacro(name, signature, transitioning, body);
+  Declare(name, macro);
+  if (op) {
+    if (TryLookupMacro(*op, signature.GetExplicitTypes())) {
+      ReportError("cannot redeclare operator ", name,
+                  " with identical explicit parameters");
+    }
+    Declare(*op, macro);
+  }
   return macro;
 }
 
+Builtin* Declarations::CreateBuiltin(const std::string& name,
+                                     Builtin::Kind kind,
+                                     const Signature& signature,
+                                     bool transitioning,
+                                     base::Optional<Statement*> body) {
+  return RegisterDeclarable(std::unique_ptr<Builtin>(
+      new Builtin(name, kind, signature, transitioning, body)));
+}
+
 Builtin* Declarations::DeclareBuiltin(const std::string& name,
-                                      Builtin::Kind kind, bool external,
+                                      Builtin::Kind kind,
                                       const Signature& signature,
-                                      bool transitioning) {
-  CheckAlreadyDeclared(name, "builtin");
-  Builtin* result = new Builtin(name, kind, external, signature, transitioning,
-                                GetCurrentGeneric());
-  Declare(name, std::unique_ptr<Declarable>(result));
-  return result;
+                                      bool transitioning,
+                                      base::Optional<Statement*> body) {
+  CheckAlreadyDeclared<Builtin>(name, "builtin");
+  return Declare(name,
+                 CreateBuiltin(name, kind, signature, transitioning, body));
 }
 
 RuntimeFunction* Declarations::DeclareRuntimeFunction(
     const std::string& name, const Signature& signature, bool transitioning) {
-  CheckAlreadyDeclared(name, "runtime function");
-  RuntimeFunction* result =
-      new RuntimeFunction(name, signature, transitioning, GetCurrentGeneric());
-  Declare(name, std::unique_ptr<Declarable>(result));
-  return result;
+  CheckAlreadyDeclared<RuntimeFunction>(name, "runtime function");
+  return Declare(name,
+                 RegisterDeclarable(std::unique_ptr<RuntimeFunction>(
+                     new RuntimeFunction(name, signature, transitioning))));
 }
 
 void Declarations::DeclareExternConstant(const std::string& name,
                                          const Type* type, std::string value) {
-  CheckAlreadyDeclared(name, "constant, parameter or arguments");
+  CheckAlreadyDeclared<Value>(name, "constant");
   ExternConstant* result = new ExternConstant(name, type, value);
   Declare(name, std::unique_ptr<Declarable>(result));
 }
 
 ModuleConstant* Declarations::DeclareModuleConstant(const std::string& name,
-                                                    const Type* type) {
-  CheckAlreadyDeclared(name, "module constant");
-  ModuleConstant* result = new ModuleConstant(name, type);
+                                                    const Type* type,
+                                                    Expression* body) {
+  CheckAlreadyDeclared<Value>(name, "constant");
+  ModuleConstant* result = new ModuleConstant(name, type, body);
   Declare(name, std::unique_ptr<Declarable>(result));
   return result;
 }
 
-Generic* Declarations::DeclareGeneric(const std::string& name, Module* module,
+Generic* Declarations::DeclareGeneric(const std::string& name,
                                       GenericDeclaration* generic) {
-  auto previous = chain_.Lookup(name);
-  GenericList* generic_list = nullptr;
-  if (previous == nullptr) {
-    generic_list = new GenericList();
-    Declare(name, std::unique_ptr<Declarable>(generic_list));
-  } else if (!previous->IsGenericList()) {
-    std::stringstream s;
-    s << "cannot redeclare non-generic " << name << " as a generic";
-    ReportError(s.str());
-  } else {
-    generic_list = GenericList::cast(previous);
-  }
-  Generic* result = RegisterDeclarable(
-      std::unique_ptr<Generic>(new Generic(name, module, generic)));
-  generic_list->AddGeneric(result);
-  generic_declaration_scopes_[result] = GetScopeChainSnapshot();
-  return result;
-}
-
-TypeVector Declarations::GetCurrentSpecializationTypeNamesVector() {
-  TypeVector result;
-  if (current_generic_specialization_ != nullptr) {
-    result = current_generic_specialization_->second;
-  }
-  return result;
-}
-
-base::Optional<Generic*> Declarations::GetCurrentGeneric() {
-  if (current_generic_specialization_ != nullptr) {
-    return current_generic_specialization_->first;
-  }
-  return base::nullopt;
+  return Declare(name, std::unique_ptr<Generic>(new Generic(name, generic)));
 }
 
-std::string GetGeneratedCallableName(const std::string& name,
-                                     const TypeVector& specialized_types) {
+std::string Declarations::GetGeneratedCallableName(
+    const std::string& name, const TypeVector& specialized_types) {
   std::string result = name;
   for (auto type : specialized_types) {
     std::string type_string = type->MangledName();

src/torque/declarations.h

@@ -8,7 +8,6 @@
 #include <string>
 
 #include "src/torque/declarable.h"
-#include "src/torque/scope.h"
 #include "src/torque/utils.h"
 
 namespace v8 {
@@ -19,196 +18,116 @@ static constexpr const char* const kFromConstexprMacroName = "FromConstexpr";
 static constexpr const char* kTrueLabelName = "_True";
 static constexpr const char* kFalseLabelName = "_False";
 
+template <class T>
+std::vector<T*> FilterDeclarables(const std::vector<Declarable*> list) {
+  std::vector<T*> result;
+  for (Declarable* declarable : list) {
+    if (T* t = T::DynamicCast(declarable)) {
+      result.push_back(t);
+    }
+  }
+  return result;
+}
+
 class Declarations {
  public:
-  Declarations()
-      : unique_declaration_number_(0),
-        current_generic_specialization_(nullptr) {}
-
-  Declarable* TryLookup(const std::string& name) { return chain_.Lookup(name); }
+  static std::vector<Declarable*> TryLookup(const std::string& name) {
+    return CurrentScope::Get()->Lookup(name);
+  }
 
-  Declarable* Lookup(const std::string& name) {
-    Declarable* d = TryLookup(name);
-    if (d == nullptr) {
-      std::stringstream s;
-      s << "cannot find \"" << name << "\"";
-      ReportError(s.str());
+  static std::vector<Declarable*> TryLookupShallow(const std::string& name) {
+    return CurrentScope::Get()->LookupShallow(name);
   }
-    return d;
+
+  template <class T>
+  static std::vector<T*> TryLookup(const std::string& name) {
+    return FilterDeclarables<T>(TryLookup(name));
   }
 
-  Declarable* LookupGlobalScope(const std::string& name) {
-    Declarable* d = chain_.LookupGlobalScope(name);
-    if (d == nullptr) {
+  static std::vector<Declarable*> Lookup(const std::string& name) {
+    std::vector<Declarable*> d = TryLookup(name);
+    if (d.empty()) {
       std::stringstream s;
-      s << "cannot find \"" << name << "\" in global scope";
+      s << "cannot find \"" << name << "\"";
       ReportError(s.str());
     }
     return d;
   }
 
-  const Type* LookupType(const std::string& name);
-  const Type* LookupGlobalType(const std::string& name);
-  const Type* GetType(TypeExpression* type_expression);
+  static std::vector<Declarable*> LookupGlobalScope(const std::string& name);
+
+  static const Type* LookupType(const std::string& name);
+  static const Type* LookupGlobalType(const std::string& name);
+  static const Type* GetType(TypeExpression* type_expression);
 
-  Builtin* FindSomeInternalBuiltinWithType(const FunctionPointerType* type);
+  static Builtin* FindSomeInternalBuiltinWithType(
+      const FunctionPointerType* type);
 
-  Value* LookupValue(const std::string& name);
+  static Value* LookupValue(const std::string& name);
 
-  Macro* TryLookupMacro(const std::string& name, const TypeVector& types);
-  Macro* LookupMacro(const std::string& name, const TypeVector& types);
+  static Macro* TryLookupMacro(const std::string& name,
+                               const TypeVector& types);
+  static base::Optional<Builtin*> TryLookupBuiltin(const std::string& name);
 
-  Builtin* LookupBuiltin(const std::string& name);
+  static std::vector<Generic*> LookupGeneric(const std::string& name);
+  static Generic* LookupUniqueGeneric(const std::string& name);
 
-  GenericList* LookupGeneric(const std::string& name);
-  ModuleConstant* LookupModuleConstant(const std::string& name);
+  static Module* DeclareModule(const std::string& name);
 
-  const AbstractType* DeclareAbstractType(
+  static const AbstractType* DeclareAbstractType(
       const std::string& name, bool transient, const std::string& generated,
       base::Optional<const AbstractType*> non_constexpr_version,
       const base::Optional<std::string>& parent = {});
 
-  void DeclareType(const std::string& name, const Type* type);
+  static void DeclareType(const std::string& name, const Type* type,
+                          bool redeclaration);
 
-  void DeclareStruct(Module* module, const std::string& name,
+  static void DeclareStruct(const std::string& name,
                             const std::vector<NameAndType>& fields);
 
-  Macro* DeclareMacro(const std::string& name, const Signature& signature,
-                      bool transitioning, base::Optional<std::string> op = {});
-
-  Builtin* DeclareBuiltin(const std::string& name, Builtin::Kind kind,
-                          bool external, const Signature& signature,
-                          bool transitioning);
-
-  RuntimeFunction* DeclareRuntimeFunction(const std::string& name,
+  static Macro* CreateMacro(const std::string& name, const Signature& signature,
+                            bool transitioning,
+                            base::Optional<Statement*> body);
+  static Macro* DeclareMacro(const std::string& name,
+                             const Signature& signature, bool transitioning,
+                             base::Optional<Statement*> body,
+                             base::Optional<std::string> op = {});
+
+  static Builtin* CreateBuiltin(const std::string& name, Builtin::Kind kind,
+                                const Signature& signature, bool transitioning,
+                                base::Optional<Statement*> body);
+  static Builtin* DeclareBuiltin(const std::string& name, Builtin::Kind kind,
+                                 const Signature& signature, bool transitioning,
+                                 base::Optional<Statement*> body);
+
+  static RuntimeFunction* DeclareRuntimeFunction(const std::string& name,
                                                  const Signature& signature,
                                                  bool transitioning);
 
-  void DeclareExternConstant(const std::string& name, const Type* type,
+  static void DeclareExternConstant(const std::string& name, const Type* type,
                                     std::string value);
-  ModuleConstant* DeclareModuleConstant(const std::string& name,
-                                        const Type* type);
+  static ModuleConstant* DeclareModuleConstant(const std::string& name,
+                                               const Type* type,
+                                               Expression* body);
 
-  Generic* DeclareGeneric(const std::string& name, Module* module,
+  static Generic* DeclareGeneric(const std::string& name,
                                  GenericDeclaration* generic);
 
-  TypeVector GetCurrentSpecializationTypeNamesVector();
-  base::Optional<Generic*> GetCurrentGeneric();
-
-  ScopeChain::Snapshot GetScopeChainSnapshot() { return chain_.TaskSnapshot(); }
-
-  bool IsDeclaredInCurrentScope(const std::string& name);
-
-  Statement* next_body() const { return next_body_; }
-
-  void PrintScopeChain() { chain_.Print(); }
-
-  class ModuleScopeActivator;
-  class NodeScopeActivator;
-  class CleanNodeScopeActivator;
-  class GenericScopeActivator;
-  class ScopedGenericSpecializationKey;
-  class ScopedGenericScopeChainSnapshot;
-
- private:
-  Scope* GetModuleScope(const Module* module);
-  Scope* GetNodeScope(const AstNode* node, bool reset_scope = false);
-  Scope* GetGenericScope(Generic* generic, const TypeVector& types);
-
   template <class T>
-  T* RegisterDeclarable(std::unique_ptr<T> d) {
-    T* ptr = d.get();
-    declarables_.push_back(std::move(d));
-    return ptr;
-  }
-
-  MacroList* GetMacroListForName(const std::string& name,
-                                 const Signature& signature);
-
-  void Declare(const std::string& name, std::unique_ptr<Declarable> d) {
-    chain_.Declare(name, RegisterDeclarable(std::move(d)));
-  }
-
-  int GetNextUniqueDeclarationNumber() { return unique_declaration_number_++; }
-
-  void CheckAlreadyDeclared(const std::string& name, const char* new_type);
-
-  int unique_declaration_number_;
-  ScopeChain chain_;
-  const SpecializationKey* current_generic_specialization_;
-  Statement* next_body_;
-  std::vector<std::unique_ptr<Declarable>> declarables_;
-  std::map<const Module*, Scope*> module_scopes_;
-  std::map<std::pair<const AstNode*, TypeVector>, Scope*> scopes_;
-  std::map<Generic*, ScopeChain::Snapshot> generic_declaration_scopes_;
-};
-
-class Declarations::NodeScopeActivator {
- public:
-  NodeScopeActivator(Declarations* declarations, AstNode* node)
-      : activator_(declarations->GetNodeScope(node)) {}
-
- private:
-  Scope::Activator activator_;
-};
-
-class Declarations::ModuleScopeActivator {
- public:
-  ModuleScopeActivator(Declarations* declarations, const Module* module)
-      : activator_(declarations->GetModuleScope(module)) {}
-
- private:
-  Scope::Activator activator_;
-};
-
-class Declarations::CleanNodeScopeActivator {
- public:
-  CleanNodeScopeActivator(Declarations* declarations, AstNode* node)
-      : activator_(declarations->GetNodeScope(node, true)) {}
-
- private:
-  Scope::Activator activator_;
-};
-
-class Declarations::GenericScopeActivator {
- public:
-  GenericScopeActivator(Declarations* declarations,
-                        const SpecializationKey& key)
-      : activator_(declarations->GetGenericScope(key.first, key.second)) {}
-
- private:
-  Scope::Activator activator_;
-};
-
-class Declarations::ScopedGenericSpecializationKey {
- public:
-  ScopedGenericSpecializationKey(Declarations* declarations,
-                                 const SpecializationKey& key)
-      : declarations_(declarations) {
-    declarations->current_generic_specialization_ = &key;
+  static T* Declare(const std::string& name, T* d) {
+    CurrentScope::Get()->AddDeclarable(name, d);
+    return d;
   }
-  ~ScopedGenericSpecializationKey() {
-    declarations_->current_generic_specialization_ = nullptr;
+  template <class T>
+  static T* Declare(const std::string& name, std::unique_ptr<T> d) {
+    return CurrentScope::Get()->AddDeclarable(name,
+                                              RegisterDeclarable(std::move(d)));
   }
 
- private:
-  Declarations* declarations_;
+  static std::string GetGeneratedCallableName(
+      const std::string& name, const TypeVector& specialized_types);
 };
 
-class Declarations::ScopedGenericScopeChainSnapshot {
- public:
-  ScopedGenericScopeChainSnapshot(Declarations* declarations,
-                                  const SpecializationKey& key)
-      : restorer_(declarations->generic_declaration_scopes_[key.first]) {}
-  ~ScopedGenericScopeChainSnapshot() = default;
-
- private:
-  ScopeChain::ScopedSnapshotRestorer restorer_;
-};
-
-std::string GetGeneratedCallableName(const std::string& name,
-                                     const TypeVector& specialized_types);
-
 }  // namespace torque
 }  // namespace internal
 }  // namespace v8

src/torque/file-visitor.cc

@@ -5,7 +5,6 @@
 #include "src/torque/file-visitor.h"
 
 #include "src/torque/declarable.h"
-#include "src/torque/parameter-difference.h"
 
 namespace v8 {
 namespace internal {
@@ -17,68 +16,19 @@ Signature FileVisitor::MakeSignature(const CallableNodeSignature* signature) {
     LabelDeclaration def = {label.name, GetTypeVector(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,
+                   arguments_variable,
                    {GetTypeVector(signature->parameters.types),
                     signature->parameters.has_varargs},
                    signature->parameters.implicit_count,
-                   declarations()->GetType(signature->return_type),
+                   Declarations::GetType(signature->return_type),
                    definition_vector};
   return result;
 }
 
-Signature FileVisitor::MakeSignatureFromReturnType(
-    TypeExpression* return_type) {
-  Signature result{
-      {}, {{}, false}, 0, declarations()->GetType(return_type), {}};
-  return result;
-}
-
-void FileVisitor::QueueGenericSpecialization(
-    const SpecializationKey& key, CallableNode* callable,
-    const CallableNodeSignature* signature, base::Optional<Statement*> body) {
-  pending_specializations_.push_back(
-      {key, callable, signature, body, CurrentSourcePosition::Get()});
-}
-
-void FileVisitor::SpecializeGeneric(
-    const PendingSpecialization& specialization) {
-  CurrentSourcePosition::Scope scope(specialization.request_position);
-  if (completed_specializations_.find(specialization.key) !=
-      completed_specializations_.end()) {
-    std::stringstream stream;
-    stream << "cannot redeclare specialization of "
-           << specialization.key.first->name() << " with types <"
-           << specialization.key.second << ">";
-    ReportError(stream.str());
-  }
-  if (!specialization.body) {
-    std::stringstream stream;
-    stream << "missing specialization of " << specialization.key.first->name()
-           << " with types <" << specialization.key.second << ">";
-    ReportError(stream.str());
-  }
-  Declarations::ScopedGenericSpecializationKey instantiation(
-      declarations(), specialization.key);
-  FileVisitor::ScopedModuleActivator activator(
-      this, specialization.key.first->module());
-  Specialize(specialization.key, specialization.callable,
-             specialization.signature, *specialization.body);
-  completed_specializations_.insert(specialization.key);
-}
-
-void FileVisitor::DrainSpecializationQueue() {
-  while (pending_specializations_.size() != 0) {
-    PendingSpecialization specialization(pending_specializations_.front());
-    pending_specializations_.pop_front();
-    if (completed_specializations_.find(specialization.key) ==
-        completed_specializations_.end()) {
-      Declarations::ScopedGenericScopeChainSnapshot scope(declarations(),
-                                                          specialization.key);
-      SpecializeGeneric(specialization);
-    }
-  }
-}
-
 }  // namespace torque
 }  // namespace internal
 }  // namespace v8

src/torque/file-visitor.h

@@ -19,74 +19,20 @@ namespace torque {
 
 class FileVisitor {
  public:
-  explicit FileVisitor(GlobalContext& global_context)
-      : global_context_(global_context),
-        declarations_(global_context.declarations()),
-        module_(global_context.GetDefaultModule()) {}
-
   TypeVector GetTypeVector(const std::vector<TypeExpression*>& v) {
     TypeVector result;
     for (TypeExpression* t : v) {
-      result.push_back(declarations()->GetType(t));
+      result.push_back(Declarations::GetType(t));
     }
     return result;
   }
 
-  Ast* ast() { return global_context_.ast(); }
-  Declarations* declarations() { return global_context_.declarations(); }
-
-  void DrainSpecializationQueue();
-
-  class ScopedModuleActivator {
-   public:
-    ScopedModuleActivator(FileVisitor* visitor, Module* module)
-        : visitor_(visitor), saved_module_(visitor->CurrentModule()) {
-      visitor->module_ = module;
-    }
-    ~ScopedModuleActivator() { visitor_->module_ = saved_module_; }
-
-   private:
-    FileVisitor* visitor_;
-    Module* saved_module_;
-  };
-
  protected:
-  Module* CurrentModule() const { return module_; }
-
-  friend class ScopedModuleActivator;
-
   std::string GetParameterVariableFromName(const std::string& name) {
     return std::string("p_") + name;
   }
 
   Signature MakeSignature(const CallableNodeSignature* signature);
-  Signature MakeSignatureFromReturnType(TypeExpression* return_type);
-
-  struct PendingSpecialization {
-    SpecializationKey key;
-    CallableNode* callable;
-    const CallableNodeSignature* signature;
-    base::Optional<Statement*> body;
-    SourcePosition request_position;
-  };
-
-  void QueueGenericSpecialization(const SpecializationKey& key,
-                                  CallableNode* callable,
-                                  const CallableNodeSignature* signature,
-                                  base::Optional<Statement*> body);
-
-  void SpecializeGeneric(const PendingSpecialization& specialization);
-
-  virtual void Specialize(const SpecializationKey&, CallableNode* callable,
-                          const CallableNodeSignature* signature,
-                          Statement* body) = 0;
-
-  GlobalContext& global_context_;
-  Declarations* declarations_;
-  std::deque<PendingSpecialization> pending_specializations_;
-  std::set<SpecializationKey> completed_specializations_;
-  Callable* current_callable_;
-  Module* module_;
 };
 
 }  // namespace torque

src/torque/global-context.h

@@ -7,98 +7,57 @@
 
 #include "src/torque/declarable.h"
 #include "src/torque/declarations.h"
-#include "src/torque/scope.h"
 #include "src/torque/type-oracle.h"
 
 namespace v8 {
 namespace internal {
 namespace torque {
 
-class GlobalContext;
-class Scope;
-class TypeOracle;
-class Builtin;
-
-class Module {
+class GlobalContext : public ContextualClass<GlobalContext> {
  public:
-  explicit Module(const std::string& name, bool is_default)
-      : name_(name), is_default_(is_default) {}
-  const std::string& name() const { return name_; }
-  bool IsDefault() const { return is_default_; }
-  std::ostream& source_stream() { return source_stream_; }
-  std::ostream& header_stream() { return header_stream_; }
-  std::string source() { return source_stream_.str(); }
-  std::string header() { return header_stream_.str(); }
-
- private:
-  std::string name_;
-  bool is_default_;
-  std::stringstream header_stream_;
-  std::stringstream source_stream_;
-};
-
-class GlobalContext {
- public:
-  explicit GlobalContext(Ast ast)
-      : verbose_(false),
-        next_label_number_(0),
-        default_module_(GetModule("base", true)),
-        ast_(std::move(ast)) {}
-  Module* GetDefaultModule() { return default_module_; }
-  Module* GetModule(const std::string& name, bool is_default = false) {
-    auto i = modules_.find(name);
-    if (i != modules_.end()) {
-      return i->second.get();
+  explicit GlobalContext(Ast ast) : verbose_(false), ast_(std::move(ast)) {
+    CurrentScope::Scope current_scope(nullptr);
+    CurrentSourcePosition::Scope current_source_position(
+        SourcePosition{CurrentSourceFile::Get(), -1, -1});
+    default_module_ = RegisterDeclarable(base::make_unique<Module>("base"));
   }
-    Module* module = new Module(name, is_default);
-    modules_[name] = std::unique_ptr<Module>(module);
-    return module;
+  static Module* GetDefaultModule() { return Get().default_module_; }
+  template <class T>
+  T* RegisterDeclarable(std::unique_ptr<T> d) {
+    T* ptr = d.get();
+    declarables_.push_back(std::move(d));
+    return ptr;
   }
 
-  int GetNextLabelNumber() { return next_label_number_++; }
-
-  const std::map<std::string, std::unique_ptr<Module>>& GetModules() const {
-    return modules_;
+  static const std::vector<std::unique_ptr<Declarable>>& AllDeclarables() {
+    return Get().declarables_;
   }
 
-  void SetVerbose() { verbose_ = true; }
-  bool verbose() const { return verbose_; }
-
-  friend class CurrentCallableActivator;
-  friend class BreakContinueActivator;
-
-  Callable* GetCurrentCallable() const { return current_callable_; }
+  static const std::vector<Module*> GetModules() {
+    std::vector<Module*> result;
+    for (auto& declarable : AllDeclarables()) {
+      if (Module* m = Module::DynamicCast(declarable.get())) {
+        result.push_back(m);
+      }
+    }
+    return result;
+  }
 
-  Declarations* declarations() { return &declarations_; }
-  Ast* ast() { return &ast_; }
+  static void SetVerbose() { Get().verbose_ = true; }
+  static bool verbose() { return Get().verbose_; }
+  static Ast* ast() { return &Get().ast_; }
 
  private:
   bool verbose_;
-  int next_label_number_;
-  Declarations declarations_;
-  Callable* current_callable_;
-  std::map<std::string, std::unique_ptr<Module>> modules_;
   Module* default_module_;
   Ast ast_;
+  std::vector<std::unique_ptr<Declarable>> declarables_;
 };
 
-class CurrentCallableActivator {
- public:
-  CurrentCallableActivator(GlobalContext& context, Callable* callable,
-                           CallableNode* decl)
-      : context_(context), scope_activator_(context.declarations(), decl) {
-    remembered_callable_ = context_.current_callable_;
-    context_.current_callable_ = callable;
-  }
-  ~CurrentCallableActivator() {
-    context_.current_callable_ = remembered_callable_;
-  }
-
- private:
-  GlobalContext& context_;
-  Callable* remembered_callable_;
-  Declarations::NodeScopeActivator scope_activator_;
-};
+template <class T>
+T* RegisterDeclarable(std::unique_ptr<T> d) {
+  return GlobalContext::Get().RegisterDeclarable(std::move(d));
+}
 
 }  // namespace torque
 }  // namespace internal

src/torque/implementation-visitor.cc

@@ -5,6 +5,7 @@
 #include <algorithm>
 
 #include "src/torque/csa-generator.h"
+#include "src/torque/declaration-visitor.h"
 #include "src/torque/implementation-visitor.h"
 #include "src/torque/parameter-difference.h"
 
@@ -44,37 +45,11 @@ const Type* ImplementationVisitor::Visit(Statement* stmt) {
   return result;
 }
 
-void ImplementationVisitor::Visit(Declaration* decl) {
-  CurrentSourcePosition::Scope scope(decl->pos);
-  switch (decl->kind) {
-#define ENUM_ITEM(name)        \
-  case AstNode::Kind::k##name: \
-    return Visit(name::cast(decl));
-    AST_DECLARATION_NODE_KIND_LIST(ENUM_ITEM)
-#undef ENUM_ITEM
-    default:
-      UNIMPLEMENTED();
-  }
-}
-
-void ImplementationVisitor::Visit(CallableNode* decl,
-                                  const Signature& signature, 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();
-  }
-}
-
 void ImplementationVisitor::BeginModuleFile(Module* module) {
   std::ostream& source = module->source_stream();
   std::ostream& header = module->header_stream();
 
-  if (module->IsDefault()) {
+  if (module == GlobalContext::GetDefaultModule()) {
     source << "#include \"src/torque-assembler.h\"";
   } else {
     source << "#include \"src/builtins/builtins-" +
@@ -109,7 +84,7 @@ void ImplementationVisitor::BeginModuleFile(Module* module) {
       std::string("V8_TORQUE_") + upper_name + "_FROM_DSL_BASE_H__";
   header << "#ifndef " << headerDefine << "\n";
   header << "#define " << headerDefine << "\n\n";
-  if (module->IsDefault()) {
+  if (module == GlobalContext::GetDefaultModule()) {
     header << "#include \"src/torque-assembler.h\"";
   } else {
     header << "#include \"src/builtins/builtins-" +
@@ -140,8 +115,6 @@ void ImplementationVisitor::EndModuleFile(Module* module) {
   std::ostream& source = module->source_stream();
   std::ostream& header = module->header_stream();
 
-  DrainSpecializationQueue();
-
   std::string upper_name(module->name());
   transform(upper_name.begin(), upper_name.end(), upper_name.begin(),
             ::toupper);
@@ -159,18 +132,9 @@ void ImplementationVisitor::EndModuleFile(Module* module) {
   header << "#endif  // " << headerDefine << "\n";
 }
 
-void ImplementationVisitor::Visit(ModuleDeclaration* decl) {
-  Module* module = decl->GetModule();
-  Module* saved_module = module_;
-  module_ = module;
-  Declarations::ModuleScopeActivator scope(declarations(), decl->GetModule());
-  for (auto& child : decl->declarations) Visit(child);
-  module_ = saved_module;
-}
-
-void ImplementationVisitor::Visit(ConstDeclaration* decl) {
-  Signature signature = MakeSignatureFromReturnType(decl->type);
-  std::string name = decl->name;
+void ImplementationVisitor::Visit(ModuleConstant* decl) {
+  Signature signature{{}, base::nullopt, {{}, false}, 0, decl->type(), {}};
+  const std::string& name = decl->name();
 
   BindingsManagersScope bindings_managers_scope;
 
@@ -187,7 +151,7 @@ void ImplementationVisitor::Visit(ConstDeclaration* decl) {
 
   assembler_ = CfgAssembler(Stack<const Type*>{});
 
-  VisitResult expression_result = Visit(decl->expression);
+  VisitResult expression_result = Visit(decl->body());
   VisitResult return_result =
       GenerateImplicitConvert(signature.return_type, expression_result);
 
@@ -202,10 +166,12 @@ void ImplementationVisitor::Visit(ConstDeclaration* decl) {
   source_out() << "}\n\n";
 }
 
-void ImplementationVisitor::Visit(StructDeclaration* decl) {
-  header_out() << "  struct " << decl->name << " {\n";
-  const StructType* struct_type =
-      static_cast<const StructType*>(declarations()->LookupType(decl->name));
+void ImplementationVisitor::Visit(TypeAlias* alias) {
+  if (alias->IsRedeclaration()) return;
+  const StructType* struct_type = StructType::DynamicCast(alias->type());
+  if (!struct_type) return;
+  const std::string& name = struct_type->name();
+  header_out() << "  struct " << name << " {\n";
   for (auto& field : struct_type->fields()) {
     header_out() << "    " << field.type->GetGeneratedTypeName();
     header_out() << " " << field.name << ";\n";
@@ -238,21 +204,17 @@ void ImplementationVisitor::Visit(StructDeclaration* decl) {
   header_out() << "  };\n";
 }
 
-void ImplementationVisitor::Visit(TorqueMacroDeclaration* decl,
-                                  const Signature& sig, Statement* body) {
-  Signature signature = MakeSignature(decl->signature.get());
-  const Type* return_type = signature.return_type;
+void ImplementationVisitor::Visit(Macro* macro) {
+  if (macro->IsExternal()) return;
+  CurrentScope::Scope current_scope(macro);
+  const Signature& signature = macro->signature();
+  const Type* return_type = macro->signature().return_type;
   bool can_return = return_type != TypeOracle::GetNeverType();
   bool has_return_value =
       can_return && return_type != TypeOracle::GetVoidType();
-  std::string name = GetGeneratedCallableName(
-      decl->name, declarations()->GetCurrentSpecializationTypeNamesVector());
-  Macro* macro =
-      declarations()->LookupMacro(name, signature.GetExplicitTypes());
 
-  CurrentCallableActivator activator(global_context_, macro, decl);
+  CurrentCallable::Scope current_callable(macro);
 
-  if (body != nullptr) {
   header_out() << "  ";
   GenerateMacroFunctionDeclaration(header_out(), "", macro);
   header_out() << ";\n";
@@ -277,8 +239,7 @@ void ImplementationVisitor::Visit(TorqueMacroDeclaration* decl,
     } else {
       LowerParameter(type, external_name, &lowered_parameters);
       StackRange range = lowered_parameter_types.PushMany(LowerType(type));
-        parameter_bindings.Add(name,
-                               LocalValue{true, VisitResult(type, range)});
+      parameter_bindings.Add(name, LocalValue{true, VisitResult(type, range)});
     }
   }
 
@@ -286,7 +247,7 @@ void ImplementationVisitor::Visit(TorqueMacroDeclaration* decl,
   assembler_ = CfgAssembler(lowered_parameter_types);
 
   BlockBindings<LocalLabel> label_bindings(&LabelBindingsManager::Get());
-    for (const LabelDeclaration& label_info : sig.labels) {
+  for (const LabelDeclaration& label_info : signature.labels) {
     Stack<const Type*> label_input_stack;
     for (const Type* type : label_info.types) {
       label_input_stack.PushMany(LowerType(type));
@@ -304,25 +265,25 @@ void ImplementationVisitor::Visit(TorqueMacroDeclaration* decl,
                               LocalLabel{macro_end, {signature.return_type}});
   }
 
-    const Type* result = Visit(body);
+  const Type* result = Visit(*macro->body());
 
   if (result->IsNever()) {
     if (!macro->signature().return_type->IsNever() && !macro->HasReturns()) {
       std::stringstream s;
-        s << "macro " << decl->name
+      s << "macro " << macro->name()
         << " that never returns must have return type never";
       ReportError(s.str());
     }
   } else {
     if (macro->signature().return_type->IsNever()) {
       std::stringstream s;
-        s << "macro " << decl->name
+      s << "macro " << macro->name()
         << " has implicit return at end of its declartion but return type "
            "never";
       ReportError(s.str());
     } else if (!macro->signature().return_type->IsVoid()) {
       std::stringstream s;
-        s << "macro " << decl->name
+      s << "macro " << macro->name()
         << " expects to return a value but doesn't on all paths";
       ReportError(s.str());
     }
@@ -354,23 +315,20 @@ void ImplementationVisitor::Visit(TorqueMacroDeclaration* decl,
 
   if (has_return_value) {
     source_out() << "  return ";
-      CSAGenerator::EmitCSAValue(GetAndClearReturnValue(), *values,
-                                 source_out());
+    CSAGenerator::EmitCSAValue(GetAndClearReturnValue(), *values, source_out());
     source_out() << ";\n";
   }
   source_out() << "}\n\n";
-  }
 }
 
 namespace {
 
-std::string AddParameter(size_t i, TorqueBuiltinDeclaration* decl,
-                         const Signature& signature,
+std::string AddParameter(size_t i, Builtin* builtin,
                          Stack<std::string>* parameters,
                          Stack<const Type*>* parameter_types,
                          BlockBindings<LocalValue>* parameter_bindings) {
-  const std::string& name = decl->signature->parameters.names[i];
-  const Type* type = signature.types()[i];
+  const std::string& name = builtin->signature().parameter_names[i];
+  const Type* type = builtin->signature().types()[i];
   std::string external_name = "parameter" + std::to_string(i);
   parameters->Push(external_name);
   StackRange range = parameter_types->PushMany(LowerType(type));
@@ -380,14 +338,14 @@ std::string AddParameter(size_t i, TorqueBuiltinDeclaration* decl,
 
 }  // namespace
 
-void ImplementationVisitor::Visit(TorqueBuiltinDeclaration* decl,
-                                  const Signature& signature, Statement* body) {
-  std::string name = GetGeneratedCallableName(
-      decl->name, declarations()->GetCurrentSpecializationTypeNamesVector());
+void ImplementationVisitor::Visit(Builtin* builtin) {
+  if (builtin->IsExternal()) return;
+  CurrentScope::Scope current_scope(builtin);
+  const std::string& name = builtin->name();
+  const Signature& signature = builtin->signature();
   source_out() << "TF_BUILTIN(" << name << ", "
                << GetDSLAssemblerName(CurrentModule()) << ") {\n";
-  Builtin* builtin = declarations()->LookupBuiltin(name);
-  CurrentCallableActivator activator(global_context_, builtin, decl);
+  CurrentCallable::Scope current_callable(builtin);
 
   Stack<const Type*> parameter_types;
   Stack<std::string> parameters;
@@ -397,7 +355,7 @@ void ImplementationVisitor::Visit(TorqueBuiltinDeclaration* decl,
   BlockBindings<LocalValue> parameter_bindings(&ValueBindingsManager::Get());
 
   // Context
-  std::string parameter0 = AddParameter(0, decl, signature, &parameters,
+  std::string parameter0 = AddParameter(0, builtin, &parameters,
                                         &parameter_types, &parameter_bindings);
   source_out() << "  TNode<Context> " << parameter0
                << " = UncheckedCast<Context>(Parameter("
@@ -406,13 +364,13 @@ void ImplementationVisitor::Visit(TorqueBuiltinDeclaration* decl,
 
   size_t first = 1;
   if (builtin->IsVarArgsJavaScript()) {
-    assert(decl->signature->parameters.has_varargs);
+    DCHECK(signature.parameter_types.var_args);
     source_out()
         << "  Node* argc = Parameter(Descriptor::kJSActualArgumentsCount);\n";
     source_out() << "  CodeStubArguments arguments_impl(this, "
                     "ChangeInt32ToIntPtr(argc));\n";
     std::string parameter1 = AddParameter(
-        1, decl, signature, &parameters, &parameter_types, &parameter_bindings);
+        1, builtin, &parameters, &parameter_types, &parameter_bindings);
 
     source_out() << "  TNode<Object> " << parameter1
                  << " = arguments_impl.GetReceiver();\n";
@@ -421,18 +379,18 @@ void ImplementationVisitor::Visit(TorqueBuiltinDeclaration* decl,
     source_out() << "USE(arguments);\n";
     source_out() << "USE(" << parameter1 << ");\n";
     parameter_bindings.Add(
-        decl->signature->parameters.arguments_variable,
+        *signature.arguments_variable,
         LocalValue{true,
                    VisitResult(TypeOracle::GetArgumentsType(), "arguments")});
     first = 2;
   }
 
-  for (size_t i = 0; i < decl->signature->parameters.names.size(); ++i) {
+  for (size_t i = 0; i < signature.parameter_names.size(); ++i) {
     if (i < first) continue;
-    const std::string& parameter_name = decl->signature->parameters.names[i];
+    const std::string& parameter_name = signature.parameter_names[i];
     const Type* type = signature.types()[i];
-    std::string var = AddParameter(i, decl, signature, &parameters,
-                                   &parameter_types, &parameter_bindings);
+    std::string var = AddParameter(i, builtin, &parameters, &parameter_types,
+                                   &parameter_bindings);
     source_out() << "  " << type->GetGeneratedTypeName() << " " << var << " = "
                  << "UncheckedCast<" << type->GetGeneratedTNodeTypeName()
                  << ">(Parameter(Descriptor::k"
@@ -441,7 +399,7 @@ void ImplementationVisitor::Visit(TorqueBuiltinDeclaration* decl,
   }
 
   assembler_ = CfgAssembler(parameter_types);
-  const Type* body_result = Visit(body);
+  const Type* body_result = Visit(*builtin->body());
   if (body_result != TypeOracle::GetNeverType()) {
     ReportError("control reaches end of builtin, expected return of a value");
   }
@@ -471,7 +429,7 @@ const Type* ImplementationVisitor::Visit(
 
   base::Optional<const Type*> type;
   if (stmt->type) {
-    type = declarations()->GetType(*stmt->type);
+    type = Declarations::GetType(*stmt->type);
     if ((*type)->IsConstexpr() && !stmt->const_qualified) {
       ReportError(
           "cannot declare variable with constexpr type. Use 'const' instead.");
@@ -675,13 +633,12 @@ VisitResult ImplementationVisitor::Visit(NumberLiteralExpression* expr) {
   // TODO(tebbi): Do not silently loose precision; support 64bit literals.
   double d = std::stod(expr->number.c_str());
   int32_t i = static_cast<int32_t>(d);
-  const Type* result_type =
-      declarations()->LookupType(CONST_FLOAT64_TYPE_STRING);
+  const Type* result_type = Declarations::LookupType(CONST_FLOAT64_TYPE_STRING);
   if (i == d) {
     if ((i >> 30) == (i >> 31)) {
-      result_type = declarations()->LookupType(CONST_INT31_TYPE_STRING);
+      result_type = Declarations::LookupType(CONST_INT31_TYPE_STRING);
     } else {
-      result_type = declarations()->LookupType(CONST_INT32_TYPE_STRING);
+      result_type = Declarations::LookupType(CONST_INT32_TYPE_STRING);
     }
   }
   return VisitResult{result_type, expr->number};
@@ -690,7 +647,7 @@ VisitResult ImplementationVisitor::Visit(NumberLiteralExpression* expr) {
 VisitResult ImplementationVisitor::Visit(AssumeTypeImpossibleExpression* expr) {
   VisitResult result = Visit(expr->expression);
   const Type* result_type =
-      SubtractType(result.type(), declarations()->GetType(expr->excluded_type));
+      SubtractType(result.type(), Declarations::GetType(expr->excluded_type));
   if (result_type->IsNever()) {
     ReportError("unreachable code");
   }
@@ -945,7 +902,7 @@ const Type* ImplementationVisitor::Visit(ExpressionStatement* stmt) {
 }
 
 const Type* ImplementationVisitor::Visit(ReturnStatement* stmt) {
-  Callable* current_callable = global_context_.GetCurrentCallable();
+  Callable* current_callable = CurrentCallable::Get();
   if (current_callable->signature().return_type->IsNever()) {
     std::stringstream s;
     s << "cannot return from a function with return type never";
@@ -991,8 +948,6 @@ const Type* ImplementationVisitor::Visit(ReturnStatement* stmt) {
 }
 
 const Type* ImplementationVisitor::Visit(ForOfLoopStatement* stmt) {
-  Declarations::NodeScopeActivator scope(declarations(), stmt);
-
   VisitResult expression_result = Visit(stmt->iterable);
   VisitResult begin = stmt->begin
                           ? Visit(*stmt->begin)
@@ -1039,7 +994,7 @@ const Type* ImplementationVisitor::Visit(ForOfLoopStatement* stmt) {
       VisitResult result = GenerateCall("[]", {{expression_result, index}, {}});
       if (stmt->var_declaration->type) {
         const Type* declared_type =
-            declarations()->GetType(*stmt->var_declaration->type);
+            Declarations::GetType(*stmt->var_declaration->type);
         result = GenerateImplicitConvert(declared_type, result);
       }
       element_result = element_scope.Yield(result);
@@ -1084,7 +1039,7 @@ VisitResult ImplementationVisitor::Visit(TryLabelExpression* expr) {
     TypeVector parameter_types;
     for (size_t i = 0; i < parameter_count; ++i) {
       const Type* type =
-          declarations()->GetType(expr->label_block->parameters.types[i]);
+          Declarations::GetType(expr->label_block->parameters.types[i]);
       parameter_types.push_back(type);
       if (type->IsConstexpr()) {
         ReportError("no constexpr type allowed for label arguments");
@@ -1165,8 +1120,6 @@ const Type* ImplementationVisitor::Visit(ContinueStatement* stmt) {
 }
 
 const Type* ImplementationVisitor::Visit(ForLoopStatement* stmt) {
-  Declarations::NodeScopeActivator scope(declarations(), stmt);
-
   BlockBindings<LocalValue> loop_bindings(&ValueBindingsManager::Get());
 
   if (stmt->var_declaration) Visit(*stmt->var_declaration, &loop_bindings);
@@ -1232,7 +1185,7 @@ void ImplementationVisitor::GenerateImplementation(const std::string& dir,
 }
 
 std::string ImplementationVisitor::GetBaseAssemblerName(Module* module) {
-  if (module == global_context_.GetDefaultModule()) {
+  if (module == GlobalContext::GetDefaultModule()) {
     return "TorqueAssembler";
   } else {
     std::string assembler_name(CamelifyString(module->name()) +
@@ -1256,7 +1209,7 @@ void ImplementationVisitor::GenerateMacroFunctionDeclaration(
 void ImplementationVisitor::GenerateFunctionDeclaration(
     std::ostream& o, const std::string& macro_prefix, const std::string& name,
     const Signature& signature, const NameVector& parameter_names) {
-  if (global_context_.verbose()) {
+  if (GlobalContext::verbose()) {
     std::cout << "generating source for declaration " << name << "\n";
   }
 
@@ -1310,17 +1263,9 @@ void ImplementationVisitor::GenerateFunctionDeclaration(
 
 namespace {
 
-void PrintMacroSignatures(std::stringstream& s, const std::string& name,
-                          const std::vector<Macro*>& macros) {
-  for (Macro* m : macros) {
-    s << "\n  " << name;
-    PrintSignature(s, m->signature(), false);
-  }
-}
-
-void FailMacroLookup(const std::string& reason, const std::string& name,
+void FailCallableLookup(const std::string& reason, const std::string& name,
                         const Arguments& arguments,
-                     const std::vector<Macro*>& candidates) {
+                        const std::vector<Signature>& candidates) {
   std::stringstream stream;
   stream << "\n"
          << reason << ": \n  " << name << "("
@@ -1333,10 +1278,21 @@ void FailMacroLookup(const std::string& reason, const std::string& name,
     }
   }
   stream << "\ncandidates are:";
-  PrintMacroSignatures(stream, name, candidates);
+  for (const Signature& signature : candidates) {
+    stream << "\n  " << name;
+    PrintSignature(stream, signature, false);
+  }
   ReportError(stream.str());
 }
 
+Callable* GetOrCreateSpecialization(const SpecializationKey& key) {
+  if (base::Optional<Callable*> specialization =
+          key.generic->GetSpecialization(key.specialized_types)) {
+    return *specialization;
+  }
+  return DeclarationVisitor().SpecializeImplicit(key);
+}
+
 }  // namespace
 
 base::Optional<Binding<LocalValue>*> ImplementationVisitor::TryLookupLocalValue(
@@ -1371,72 +1327,79 @@ Callable* ImplementationVisitor::LookupCall(
     const TypeVector& specialization_types) {
   Callable* result = nullptr;
   TypeVector parameter_types(arguments.parameters.GetTypeVector());
-  bool has_template_arguments = !specialization_types.empty();
-  std::string mangled_name = name;
-  if (has_template_arguments) {
-    mangled_name = GetGeneratedCallableName(name, specialization_types);
-  }
-  Declarable* declarable = declarations()->Lookup(mangled_name);
-  if (declarable->IsBuiltin()) {
-    result = Builtin::cast(declarable);
-  } else if (declarable->IsRuntimeFunction()) {
-    result = RuntimeFunction::cast(declarable);
-  } else if (declarable->IsMacroList()) {
-    std::vector<Macro*> candidates;
-    std::vector<Macro*> macros_with_same_name;
-    for (Macro* m : MacroList::cast(declarable)->list()) {
-      bool try_bool_context =
-          arguments.labels.size() == 0 &&
-          m->signature().return_type == TypeOracle::GetNeverType();
+
+  std::vector<Declarable*> overloads;
+  std::vector<Signature> overload_signatures;
+  for (Declarable* declarable : Declarations::Lookup(name)) {
+    if (Generic* generic = Generic::DynamicCast(declarable)) {
+      if (generic->generic_parameters().size() != specialization_types.size()) {
+        continue;
+      }
+      overloads.push_back(generic);
+      overload_signatures.push_back(
+          DeclarationVisitor().MakeSpecializedSignature(
+              SpecializationKey{generic, specialization_types}));
+    } else if (Callable* callable = Callable::DynamicCast(declarable)) {
+      overloads.push_back(callable);
+      overload_signatures.push_back(callable->signature());
+    }
+  }
+  // Indices of candidates in overloads/overload_signatures.
+  std::vector<size_t> candidates;
+  for (size_t i = 0; i < overloads.size(); ++i) {
+    const Signature& signature = overload_signatures[i];
+    bool try_bool_context = arguments.labels.size() == 0 &&
+                            signature.return_type == TypeOracle::GetNeverType();
     base::Optional<Binding<LocalLabel>*> true_label;
     base::Optional<Binding<LocalLabel>*> false_label;
     if (try_bool_context) {
       true_label = TryLookupLabel(kTrueLabelName);
       false_label = TryLookupLabel(kFalseLabelName);
     }
-      if (IsCompatibleSignature(m->signature(), parameter_types,
-                                arguments.labels) ||
+    if (IsCompatibleSignature(signature, parameter_types, arguments.labels) ||
         (true_label && false_label &&
-           IsCompatibleSignature(m->signature(), parameter_types,
+         IsCompatibleSignature(signature, parameter_types,
                                {*true_label, *false_label}))) {
-        candidates.push_back(m);
-      } else {
-        macros_with_same_name.push_back(m);
+      candidates.push_back(i);
     }
   }
 
-    if (candidates.empty() && macros_with_same_name.empty()) {
+  if (overloads.empty()) {
     std::stringstream stream;
     stream << "no matching declaration found for " << name;
     ReportError(stream.str());
   } else if (candidates.empty()) {
-      FailMacroLookup("cannot find macro with name", name, arguments,
-                      macros_with_same_name);
+    FailCallableLookup("cannot find suitable callable with name", name,
+                       arguments, overload_signatures);
   }
 
-    auto is_better_candidate = [&](Macro* a, Macro* b) {
-      return ParameterDifference(a->signature().GetExplicitTypes(),
+  auto is_better_candidate = [&](size_t a, size_t b) {
+    return ParameterDifference(overload_signatures[a].GetExplicitTypes(),
                                parameter_types)
         .StrictlyBetterThan(ParameterDifference(
-              b->signature().GetExplicitTypes(), parameter_types));
+            overload_signatures[b].GetExplicitTypes(), parameter_types));
   };
 
-    Macro* best = *std::min_element(candidates.begin(), candidates.end(),
+  size_t best = *std::min_element(candidates.begin(), candidates.end(),
                                   is_better_candidate);
   // This check is contained in libstdc++'s std::min_element.
   DCHECK(!is_better_candidate(best, best));
-    for (Macro* candidate : candidates) {
+  for (size_t candidate : candidates) {
     if (candidate != best && !is_better_candidate(best, candidate)) {
-        FailMacroLookup("ambiguous macro", name, arguments, candidates);
+      std::vector<Signature> candidate_signatures;
+      for (size_t i : candidates) {
+        candidate_signatures.push_back(overload_signatures[i]);
+      }
+      FailCallableLookup("ambiguous callable", name, arguments,
+                         candidate_signatures);
     }
   }
-    result = best;
+
+  if (Generic* generic = Generic::DynamicCast(overloads[best])) {
+    result = GetOrCreateSpecialization(
+        SpecializationKey{generic, specialization_types});
   } else {
-    std::stringstream stream;
-    stream << "can't call " << declarable->type_name() << " " << name
-           << " because it's not callable"
-           << ": call parameters were (" << parameter_types << ")";
-    ReportError(stream.str());
+    result = Callable::cast(overloads[best]);
   }
 
   size_t caller_size = parameter_types.size();
@@ -1451,16 +1414,6 @@ Callable* ImplementationVisitor::LookupCall(
     ReportError(stream.str());
   }
 
-  if (has_template_arguments) {
-    Generic* generic = *result->generic();
-    CallableNode* callable = generic->declaration()->callable;
-    if (generic->declaration()->body) {
-      QueueGenericSpecialization({generic, specialization_types}, callable,
-                                 callable->signature.get(),
-                                 generic->declaration()->body);
-    }
-  }
-
   return result;
 }
 
@@ -1487,7 +1440,7 @@ VisitResult ImplementationVisitor::GenerateCopy(const VisitResult& to_copy) {
 }
 
 VisitResult ImplementationVisitor::Visit(StructExpression* decl) {
-  const Type* raw_type = declarations()->LookupType(decl->name);
+  const Type* raw_type = Declarations::LookupType(decl->name);
   if (!raw_type->IsStructType()) {
     std::stringstream s;
     s << decl->name << " is not a struct but used like one ";
@@ -1567,25 +1520,24 @@ LocationReference ImplementationVisitor::GetLocationReference(
   }
 
   std::string name = expr->name;
-  if (expr->generic_arguments.size() != 0) {
-    GenericList* generic_list = declarations()->LookupGeneric(expr->name);
-    for (Generic* generic : generic_list->list()) {
-      TypeVector specialization_types = GetTypeVector(expr->generic_arguments);
-      name = GetGeneratedCallableName(name, specialization_types);
-      CallableNode* callable = generic->declaration()->callable;
-      QueueGenericSpecialization({generic, specialization_types}, callable,
-                                 callable->signature.get(),
-                                 generic->declaration()->body);
-    }
+  if (base::Optional<Builtin*> builtin = Declarations::TryLookupBuiltin(name)) {
+    return LocationReference::Temporary(GetBuiltinCode(*builtin),
+                                        "builtin " + expr->name);
   }
-  if (Builtin* builtin = Builtin::DynamicCast(declarations()->Lookup(name))) {
+  if (expr->generic_arguments.size() != 0) {
+    Generic* generic = Declarations::LookupUniqueGeneric(name);
+    Callable* specialization = GetOrCreateSpecialization(
+        SpecializationKey{generic, GetTypeVector(expr->generic_arguments)});
+    if (Builtin* builtin = Builtin::DynamicCast(specialization)) {
+      DCHECK(!builtin->IsExternal());
       return LocationReference::Temporary(GetBuiltinCode(builtin),
                                           "builtin " + expr->name);
+    } else {
+      ReportError("cannot create function pointer for non-builtin ",
+                  generic->name());
     }
-  if (expr->generic_arguments.size() != 0) {
-    ReportError("cannot have generic parameters on constant", expr->name);
   }
-  Value* value = declarations()->LookupValue(expr->name);
+  Value* value = Declarations::LookupValue(expr->name);
   if (auto* constant = ModuleConstant::DynamicCast(value)) {
     if (constant->type()->IsConstexpr()) {
       return LocationReference::Temporary(
@@ -1678,16 +1630,8 @@ VisitResult ImplementationVisitor::GeneratePointerCall(
             .stack_range());
   }
 
-  Builtin* example_builtin =
-      declarations()->FindSomeInternalBuiltinWithType(type);
-  if (!example_builtin) {
-    std::stringstream stream;
-    stream << "unable to find any builtin with type \"" << *type << "\"";
-    ReportError(stream.str());
-  }
-
-  assembler().Emit(CallBuiltinPointerInstruction{is_tailcall, example_builtin,
-                                                 arg_range.Size()});
+  assembler().Emit(
+      CallBuiltinPointerInstruction{is_tailcall, type, arg_range.Size()});
 
   if (is_tailcall) {
     return VisitResult::NeverResult();
@@ -1755,7 +1699,7 @@ VisitResult ImplementationVisitor::GenerateCall(
     }
   }
 
-  if (global_context_.verbose()) {
+  if (GlobalContext::verbose()) {
     std::cout << "generating code for call to " << callable_name << "\n";
   }
 
@@ -1769,9 +1713,9 @@ VisitResult ImplementationVisitor::GenerateCall(
   }
 
   if (callable->IsTransitioning()) {
-    if (!global_context_.GetCurrentCallable()->IsTransitioning()) {
+    if (!CurrentCallable::Get()->IsTransitioning()) {
       std::stringstream s;
-      s << *global_context_.GetCurrentCallable()
+      s << *CurrentCallable::Get()
         << " isn't marked transitioning but calls the transitioning "
         << *callable;
       ReportError(s.str());
@@ -1892,39 +1836,6 @@ VisitResult ImplementationVisitor::GenerateCall(
   }
 }
 
-void ImplementationVisitor::Visit(StandardDeclaration* decl) {
-  Signature signature = MakeSignature(decl->callable->signature.get());
-  Visit(decl->callable, signature, decl->body);
-}
-
-void ImplementationVisitor::Visit(SpecializationDeclaration* decl) {
-  Signature signature_with_types = MakeSignature(decl->signature.get());
-  Declarations::NodeScopeActivator specialization_activator(declarations(),
-                                                            decl);
-  GenericList* generic_list = declarations()->LookupGeneric(decl->name);
-  for (Generic* generic : generic_list->list()) {
-    CallableNode* callable = generic->declaration()->callable;
-    Signature generic_signature_with_types =
-        MakeSignature(callable->signature.get());
-    if (signature_with_types.HasSameTypesAs(generic_signature_with_types,
-                                            ParameterMode::kIgnoreImplicit)) {
-      TypeVector specialization_types = GetTypeVector(decl->generic_parameters);
-      SpecializeGeneric({{generic, specialization_types},
-                         callable,
-                         decl->signature.get(),
-                         decl->body,
-                         decl->pos});
-      return;
-    }
-  }
-  // Because the DeclarationVisitor already performed the same lookup
-  // as above to find aspecialization match and already threw if it didn't
-  // find one, failure to find a match here should never happen.
-  // TODO(danno): Remember the specialization found in the declaration visitor
-  //              so that the lookup doesn't have to be repeated here.
-  UNREACHABLE();
-}
-
 VisitResult ImplementationVisitor::Visit(CallExpression* expr,
                                          bool is_tailcall) {
   StackScope scope(this);
@@ -1989,9 +1900,8 @@ VisitResult ImplementationVisitor::GenerateImplicitConvert(
 
   if (TypeOracle::IsImplicitlyConvertableFrom(destination_type,
                                               source.type())) {
-    std::string name =
-        GetGeneratedCallableName(kFromConstexprMacroName, {destination_type});
-    return scope.Yield(GenerateCall(name, {{source}, {}}, {}, false));
+    return scope.Yield(GenerateCall(kFromConstexprMacroName, {{source}, {}},
+                                    {destination_type}, false));
   } else if (IsAssignableFrom(destination_type, source.type())) {
     source.SetType(destination_type);
     return scope.Yield(GenerateCopy(source));
@@ -2053,6 +1963,7 @@ std::string ImplementationVisitor::ExternalParameterName(
 
 DEFINE_CONTEXTUAL_VARIABLE(ImplementationVisitor::ValueBindingsManager);
 DEFINE_CONTEXTUAL_VARIABLE(ImplementationVisitor::LabelBindingsManager);
+DEFINE_CONTEXTUAL_VARIABLE(ImplementationVisitor::CurrentCallable);
 
 bool IsCompatibleSignature(const Signature& sig, const TypeVector& types,
                            const std::vector<Binding<LocalLabel>*>& labels) {
@@ -2099,6 +2010,104 @@ void ImplementationVisitor::GenerateCatchBlock(
   }
 }
 
+void ImplementationVisitor::VisitAllDeclarables() {
+  const std::vector<std::unique_ptr<Declarable>>& all_declarables =
+      GlobalContext::AllDeclarables();
+  // This has to be an index-based loop because all_declarables can be extended
+  // during the loop.
+  for (size_t i = 0; i < all_declarables.size(); ++i) {
+    Visit(all_declarables[i].get());
+  }
+}
+
+void ImplementationVisitor::Visit(Declarable* declarable) {
+  CurrentScope::Scope current_scope(declarable->ParentScope());
+  CurrentSourcePosition::Scope current_source_position(declarable->pos());
+  switch (declarable->kind()) {
+    case Declarable::kMacro:
+      return Visit(Macro::cast(declarable));
+    case Declarable::kBuiltin:
+      return Visit(Builtin::cast(declarable));
+    case Declarable::kTypeAlias:
+      return Visit(TypeAlias::cast(declarable));
+    case Declarable::kModuleConstant:
+      return Visit(ModuleConstant::cast(declarable));
+    case Declarable::kRuntimeFunction:
+    case Declarable::kExternConstant:
+    case Declarable::kModule:
+    case Declarable::kGeneric:
+      return;
+  }
+}
+
+void ImplementationVisitor::GenerateBuiltinDefinitions(std::string& file_name) {
+  std::stringstream new_contents_stream;
+  new_contents_stream
+      << "#ifndef V8_BUILTINS_BUILTIN_DEFINITIONS_FROM_DSL_H_\n"
+         "#define V8_BUILTINS_BUILTIN_DEFINITIONS_FROM_DSL_H_\n"
+         "\n"
+         "#define BUILTIN_LIST_FROM_DSL(CPP, API, TFJ, TFC, TFS, TFH, ASM) "
+         "\\\n";
+  for (auto& declarable : GlobalContext::AllDeclarables()) {
+    Builtin* builtin = Builtin::DynamicCast(declarable.get());
+    if (!builtin || builtin->IsExternal()) continue;
+    int firstParameterIndex = 1;
+    bool declareParameters = true;
+    if (builtin->IsStub()) {
+      new_contents_stream << "TFS(" << builtin->name();
+    } else {
+      new_contents_stream << "TFJ(" << builtin->name();
+      if (builtin->IsVarArgsJavaScript()) {
+        new_contents_stream
+            << ", SharedFunctionInfo::kDontAdaptArgumentsSentinel";
+        declareParameters = false;
+      } else {
+        assert(builtin->IsFixedArgsJavaScript());
+        // FixedArg javascript builtins need to offer the parameter
+        // count.
+        assert(builtin->parameter_names().size() >= 2);
+        new_contents_stream << ", " << (builtin->parameter_names().size() - 2);
+        // And the receiver is explicitly declared.
+        new_contents_stream << ", kReceiver";
+        firstParameterIndex = 2;
+      }
+    }
+    if (declareParameters) {
+      int index = 0;
+      for (const auto& parameter : builtin->parameter_names()) {
+        if (index >= firstParameterIndex) {
+          new_contents_stream << ", k" << CamelifyString(parameter);
+        }
+        index++;
+      }
+    }
+    new_contents_stream << ") \\\n";
+  }
+  new_contents_stream << "\n";
+
+  new_contents_stream
+      << "#define TORQUE_FUNCTION_POINTER_TYPE_TO_BUILTIN_MAP(V) \\\n";
+  for (const FunctionPointerType* type :
+       TypeOracle::AllFunctionPointerTypes()) {
+    Builtin* example_builtin =
+        Declarations::FindSomeInternalBuiltinWithType(type);
+    if (!example_builtin) {
+      CurrentSourcePosition::Scope current_source_position(
+          SourcePosition{CurrentSourceFile::Get(), -1, -1});
+      ReportError("unable to find any builtin with type \"", *type, "\"");
+    }
+    new_contents_stream << "  V(" << type->function_pointer_type_id() << ","
+                        << example_builtin->name() << ")\\\n";
+  }
+  new_contents_stream << "\n";
+
+  new_contents_stream
+      << "#endif  // V8_BUILTINS_BUILTIN_DEFINITIONS_FROM_DSL_H_\n";
+
+  std::string new_contents(new_contents_stream.str());
+  ReplaceFileContentsIfDifferent(file_name, new_contents);
+}
+
 }  // namespace torque
 }  // namespace internal
 }  // namespace v8

src/torque/implementation-visitor.h

@@ -199,14 +199,10 @@ bool IsCompatibleSignature(const Signature& sig, const TypeVector& types,
 
 class ImplementationVisitor : public FileVisitor {
  public:
-  explicit ImplementationVisitor(GlobalContext& global_context)
-      : FileVisitor(global_context) {}
-
-  void Visit(Ast* ast) { Visit(ast->default_module()); }
+  void GenerateBuiltinDefinitions(std::string& file_name);
 
   VisitResult Visit(Expression* expr);
   const Type* Visit(Statement* stmt);
-  void Visit(Declaration* decl);
 
   VisitResult Visit(StructExpression* decl);
 
@@ -229,33 +225,12 @@ class ImplementationVisitor : public FileVisitor {
     return scope.Yield(GenerateFetchFromLocation(GetLocationReference(expr)));
   }
 
-  void Visit(ModuleDeclaration* decl);
-  void Visit(DefaultModuleDeclaration* decl) {
-    Visit(implicit_cast<ModuleDeclaration*>(decl));
-  }
-  void Visit(ExplicitModuleDeclaration* decl) {
-    Visit(implicit_cast<ModuleDeclaration*>(decl));
-  }
-  void Visit(TypeDeclaration* decl) {}
-  void Visit(TypeAliasDeclaration* decl) {}
-  void Visit(ExternConstDeclaration* decl) {}
-  void Visit(StructDeclaration* decl);
-  void Visit(StandardDeclaration* decl);
-  void Visit(GenericDeclaration* decl) {}
-  void Visit(SpecializationDeclaration* decl);
-
-  void Visit(TorqueMacroDeclaration* decl, const Signature& signature,
-             Statement* body);
-  void Visit(TorqueBuiltinDeclaration* decl, const Signature& signature,
-             Statement* body);
-  void Visit(ExternalMacroDeclaration* decl, const Signature& signature,
-             Statement* body) {}
-  void Visit(ExternalBuiltinDeclaration* decl, const Signature& signature,
-             Statement* body) {}
-  void Visit(ExternalRuntimeDeclaration* decl, const Signature& signature,
-             Statement* body) {}
-  void Visit(CallableNode* decl, const Signature& signature, Statement* body);
-  void Visit(ConstDeclaration* decl);
+  void VisitAllDeclarables();
+  void Visit(Declarable* delarable);
+  void Visit(TypeAlias* decl);
+  void Visit(Macro* macro);
+  void Visit(Builtin* builtin);
+  void Visit(ModuleConstant* decl);
 
   VisitResult Visit(CallExpression* expr, bool is_tail = false);
   const Type* Visit(TailCallStatement* stmt);
@@ -298,6 +273,7 @@ class ImplementationVisitor : public FileVisitor {
                               BindingsManager<LocalValue>);
   DECLARE_CONTEXTUAL_VARIABLE(LabelBindingsManager,
                               BindingsManager<LocalLabel>);
+  DECLARE_CONTEXTUAL_VARIABLE(CurrentCallable, Callable*);
 
   // A BindingsManagersScope has to be active for local bindings to be created.
   // Shadowing an existing BindingsManagersScope by creating a new one hides all
@@ -431,13 +407,6 @@ class ImplementationVisitor : public FileVisitor {
   VisitResult GenerateImplicitConvert(const Type* destination_type,
                                       VisitResult source);
 
-  void Specialize(const SpecializationKey& key, CallableNode* callable,
-                  const CallableNodeSignature* signature,
-                  Statement* body) override {
-    Declarations::GenericScopeActivator scope(declarations(), key);
-    Visit(callable, MakeSignature(signature), body);
-  }
-
   StackRange GenerateLabelGoto(LocalLabel* label,
                                base::Optional<StackRange> arguments = {});
 
@@ -452,9 +421,9 @@ class ImplementationVisitor : public FileVisitor {
                                          size_t i);
   std::string ExternalParameterName(const std::string& name);
 
-  std::ostream& source_out() { return module_->source_stream(); }
+  std::ostream& source_out() { return CurrentModule()->source_stream(); }
 
-  std::ostream& header_out() { return module_->header_stream(); }
+  std::ostream& header_out() { return CurrentModule()->header_stream(); }
 
   CfgAssembler& assembler() { return *assembler_; }
 

src/torque/instructions.cc

@@ -190,9 +190,9 @@ void CallBuiltinPointerInstruction::TypeInstruction(
   if (argument_types != LowerParameterTypes(f->parameter_types())) {
     ReportError("wrong argument types");
   }
-  if (example_builtin->IsTransitioning()) {
+  // TODO(tebbi): Only invalidate transient types if the function pointer type
+  // is transitioning.
   InvalidateTransientTypes(stack);
-  }
   stack->PushMany(LowerType(f->return_type()));
 }
 

src/torque/instructions.h

@@ -252,14 +252,12 @@ struct CallBuiltinInstruction : InstructionBase {
 struct CallBuiltinPointerInstruction : InstructionBase {
   TORQUE_INSTRUCTION_BOILERPLATE()
   bool IsBlockTerminator() const override { return is_tailcall; }
-  CallBuiltinPointerInstruction(bool is_tailcall, Builtin* example_builtin,
-                                size_t argc)
-      : is_tailcall(is_tailcall),
-        example_builtin(example_builtin),
-        argc(argc) {}
+  CallBuiltinPointerInstruction(bool is_tailcall,
+                                const FunctionPointerType* type, size_t argc)
+      : is_tailcall(is_tailcall), type(type), argc(argc) {}
 
   bool is_tailcall;
-  Builtin* example_builtin;
+  const FunctionPointerType* type;
   size_t argc;
 };
 

src/torque/scope.cc

-// Copyright 2017 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include <fstream>
-#include <iostream>
-#include <string>
-
-#include "src/torque/global-context.h"
-
-#include "src/torque/scope.h"
-
-namespace v8 {
-namespace internal {
-namespace torque {
-
-Scope::Scope(ScopeChain& scope_chain)
-    : scope_chain_(scope_chain),
-      scope_number_(scope_chain_.GetNextScopeNumber()),
-      private_label_number_(0) {}
-
-Scope* ScopeChain::NewScope() {
-  Scope* new_scope = new Scope(*this);
-  scopes_.emplace_back(std::unique_ptr<Scope>(new_scope));
-  return new_scope;
-}
-
-void Scope::Print() {
-  std::cout << "scope #" << std::to_string(scope_number_) << "\n";
-  for (auto& i : lookup_) {
-    std::cout << i.first << ": " << i.second << "\n";
-  }
-}
-
-Scope::Activator::Activator(Scope* scope) : scope_(scope) {
-  scope->GetScopeChain().PushScope(scope);
-}
-
-Scope::Activator::~Activator() { scope_->GetScopeChain().PopScope(); }
-
-}  // namespace torque
-}  // namespace internal
-}  // namespace v8

src/torque/scope.h

-// Copyright 2017 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef V8_TORQUE_SCOPE_H_
-#define V8_TORQUE_SCOPE_H_
-
-#include <map>
-#include <string>
-
-#include "src/torque/ast.h"
-#include "src/torque/types.h"
-#include "src/torque/utils.h"
-
-namespace v8 {
-namespace internal {
-namespace torque {
-
-class ScopeChain;
-class Declarable;
-
-class Scope {
- public:
-  explicit Scope(ScopeChain& scope_chain);
-
-  void Stream(std::ostream& stream) const {
-    stream << "scope " << std::to_string(scope_number_) << " {";
-    for (auto& c : lookup_) {
-      stream << c.first << ",";
-    }
-    stream << "}";
-  }
-
-  int scope_number() const { return scope_number_; }
-
-  ScopeChain& GetScopeChain() const { return scope_chain_; }
-
-  void Print();
-
-  class Activator;
-
- private:
-  friend class ScopeChain;
-
-  void CheckAlreadyDeclared(SourcePosition pos, const std::string& name,
-                            const char* new_type);
-
-  void Declare(const std::string& name, Declarable* d) {
-    DCHECK_EQ(lookup_.end(), lookup_.find(name));
-    DCHECK(d != nullptr);
-    lookup_[name] = d;
-  }
-
-  Declarable* Lookup(const std::string& name) {
-    auto i = lookup_.find(name);
-    if (i == lookup_.end()) {
-      return nullptr;
-    }
-    return i->second;
-  }
-
-  ScopeChain& scope_chain_;
-  int scope_number_;
-  int private_label_number_;
-  std::map<std::string, Declarable*> lookup_;
-};
-
-class Scope::Activator {
- public:
-  explicit Activator(Scope* scope);
-  ~Activator();
-
- private:
-  Scope* scope_;
-};
-
-class ScopeChain {
- public:
-  ScopeChain() : next_scope_number_(0) {}
-  Scope* NewScope();
-
-  Scope* TopScope() const { return current_scopes_.back(); }
-  void PushScope(Scope* scope) { current_scopes_.push_back(scope); }
-  void PopScope() { current_scopes_.pop_back(); }
-
-  void Declare(const std::string& name, Declarable* d) {
-    TopScope()->Declare(name, d);
-  }
-
-  Declarable* Lookup(const std::string& name) {
-    auto e = current_scopes_.rend();
-    auto c = current_scopes_.rbegin();
-    while (c != e) {
-      Declarable* result = (*c)->Lookup(name);
-      if (result != nullptr) return result;
-      ++c;
-    }
-    return nullptr;
-  }
-
-  Declarable* ShallowLookup(const std::string& name) {
-    auto& e = current_scopes_.back();
-    return e->Lookup(name);
-  }
-
-  Declarable* LookupGlobalScope(const std::string& name) {
-    auto& e = current_scopes_.front();
-    return e->Lookup(name);
-  }
-
-  void Print() {
-    for (auto s : current_scopes_) {
-      s->Print();
-    }
-  }
-
-  struct Snapshot {
-    ScopeChain* chain;
-    std::vector<Scope*> current_scopes;
-  };
-
-  Snapshot TaskSnapshot() { return {this, current_scopes_}; }
-
-  class ScopedSnapshotRestorer {
-   public:
-    explicit ScopedSnapshotRestorer(const Snapshot& snapshot)
-        : chain_(snapshot.chain) {
-      saved_ = chain_->current_scopes_;
-      chain_->current_scopes_ = snapshot.current_scopes;
-    }
-    ~ScopedSnapshotRestorer() { chain_->current_scopes_ = saved_; }
-
-   private:
-    ScopeChain* chain_;
-    std::vector<Scope*> saved_;
-  };
-
- private:
-  friend class Scope;
-  friend class ScopedSnapshotRestorer;
-
-  int GetNextScopeNumber() { return next_scope_number_++; }
-
-  int next_scope_number_;
-  std::vector<std::unique_ptr<Scope>> scopes_;
-  std::vector<Scope*> current_scopes_;
-};
-
-inline std::ostream& operator<<(std::ostream& os, const Scope& scope) {
-  scope.Stream(os);
-  return os;
-}
-
-}  // namespace torque
-}  // namespace internal
-}  // namespace v8
-
-#endif  // V8_TORQUE_SCOPE_H_

src/torque/torque-parser.cc

@@ -364,7 +364,7 @@ base::Optional<ParseResult> MakeExternalMacro(
       transitioning, name, operator_name, args, return_type, labels);
   Declaration* result;
   if (generic_parameters.empty()) {
-    result = MakeNode<StandardDeclaration>(macro, nullptr);
+    result = MakeNode<StandardDeclaration>(macro, base::nullopt);
   } else {
     result = MakeNode<GenericDeclaration>(macro, generic_parameters);
   }
@@ -475,15 +475,15 @@ base::Optional<ParseResult> MakeTypeDeclaration(
   return ParseResult{result};
 }
 
-base::Optional<ParseResult> MakeExplicitModuleDeclaration(
+base::Optional<ParseResult> MakeModuleDeclaration(
     ParseResultIterator* child_results) {
   auto name = child_results->NextAs<std::string>();
   if (!IsSnakeCase(name)) {
     NamingConventionError("Module", name, "snake_case");
   }
   auto declarations = child_results->NextAs<std::vector<Declaration*>>();
-  Declaration* result = MakeNode<ExplicitModuleDeclaration>(
-      std::move(name), std::move(declarations));
+  Declaration* result =
+      MakeNode<ModuleDeclaration>(std::move(name), std::move(declarations));
   return ParseResult{result};
 }
 
@@ -526,7 +526,7 @@ base::Optional<ParseResult> MakeExternalBuiltin(
       transitioning, js_linkage, name, args, return_type);
   Declaration* result;
   if (generic_parameters.empty()) {
-    result = MakeNode<StandardDeclaration>(builtin, nullptr);
+    result = MakeNode<StandardDeclaration>(builtin, base::nullopt);
   } else {
     result = MakeNode<GenericDeclaration>(builtin, generic_parameters);
   }
@@ -541,7 +541,7 @@ base::Optional<ParseResult> MakeExternalRuntime(
   auto return_type = child_results->NextAs<TypeExpression*>();
   ExternalRuntimeDeclaration* runtime = MakeNode<ExternalRuntimeDeclaration>(
       transitioning, name, args, return_type);
-  Declaration* result = MakeNode<StandardDeclaration>(runtime, nullptr);
+  Declaration* result = MakeNode<StandardDeclaration>(runtime, base::nullopt);
   return ParseResult{result};
 }
 
@@ -1448,7 +1448,7 @@ struct TorqueGrammar : Grammar {
   Symbol moduleDeclaration = {
       Rule({Token("module"), &identifier, Token("{"),
             List<Declaration*>(&declaration), Token("}")},
-           MakeExplicitModuleDeclaration)};
+           MakeModuleDeclaration)};
 
   Symbol file = {Rule({&file, &moduleDeclaration}, AddGlobalDeclaration),
                  Rule({&file, &declaration}, AddGlobalDeclaration), Rule({})};

src/torque/torque.cc

@@ -9,7 +9,6 @@
 #include "src/torque/declaration-visitor.h"
 #include "src/torque/global-context.h"
 #include "src/torque/implementation-visitor.h"
-#include "src/torque/scope.h"
 #include "src/torque/torque-parser.h"
 #include "src/torque/type-oracle.h"
 #include "src/torque/types.h"
@@ -51,31 +50,27 @@ int WrappedMain(int argc, const char** argv) {
     ParseTorque(file_content);
   }
 
-  GlobalContext global_context(std::move(CurrentAst::Get()));
-  if (verbose) global_context.SetVerbose();
-  TypeOracle::Scope type_oracle(global_context.declarations());
+  GlobalContext::Scope global_context(std::move(CurrentAst::Get()));
+  if (verbose) GlobalContext::SetVerbose();
+  TypeOracle::Scope type_oracle;
 
   if (output_directory.length() != 0) {
-    {
-      DeclarationVisitor visitor(global_context);
+    DeclarationVisitor().Visit(GlobalContext::Get().ast());
 
-      visitor.Visit(global_context.ast());
-
-      std::string output_header_path = output_directory;
-      output_header_path += "/builtin-definitions-from-dsl.h";
-      visitor.GenerateHeader(output_header_path);
+    ImplementationVisitor visitor;
+    for (Module* module : GlobalContext::Get().GetModules()) {
+      visitor.BeginModuleFile(module);
     }
 
-    ImplementationVisitor visitor(global_context);
-    for (auto& module : global_context.GetModules()) {
-      visitor.BeginModuleFile(module.second.get());
-    }
+    visitor.VisitAllDeclarables();
 
-    visitor.Visit(global_context.ast());
+    std::string output_header_path = output_directory;
+    output_header_path += "/builtin-definitions-from-dsl.h";
+    visitor.GenerateBuiltinDefinitions(output_header_path);
 
-    for (auto& module : global_context.GetModules()) {
-      visitor.EndModuleFile(module.second.get());
-      visitor.GenerateImplementation(output_directory, module.second.get());
+    for (Module* module : GlobalContext::Get().GetModules()) {
+      visitor.EndModuleFile(module);
+      visitor.GenerateImplementation(output_directory, module);
     }
   }
 

src/torque/type-oracle.h

@@ -17,9 +17,6 @@ namespace torque {
 
 class TypeOracle : public ContextualClass<TypeOracle> {
  public:
-  explicit TypeOracle(Declarations* declarations)
-      : declarations_(declarations) {}
-
   static const AbstractType* GetAbstractType(
       const Type* parent, std::string name, bool transient,
       std::string generated,
@@ -32,18 +29,29 @@ class TypeOracle : public ContextualClass<TypeOracle> {
   }
 
   static const StructType* GetStructType(
-      Module* module, const std::string& name,
-      const std::vector<NameAndType>& fields) {
-    StructType* result = new StructType(module, name, fields);
+      const std::string& name, const std::vector<NameAndType>& fields) {
+    StructType* result = new StructType(CurrentModule(), name, fields);
     Get().struct_types_.push_back(std::unique_ptr<StructType>(result));
     return result;
   }
 
   static const FunctionPointerType* GetFunctionPointerType(
       TypeVector argument_types, const Type* return_type) {
-    const Type* code_type = Get().GetBuiltinType(CODE_TYPE_STRING);
-    return Get().function_pointer_types_.Add(
-        FunctionPointerType(code_type, argument_types, return_type));
+    TypeOracle& self = Get();
+    const Type* code_type = self.GetBuiltinType(CODE_TYPE_STRING);
+    const FunctionPointerType* result = self.function_pointer_types_.Add(
+        FunctionPointerType(code_type, argument_types, return_type,
+                            self.all_function_pointer_types_.size()));
+    if (result->function_pointer_type_id() ==
+        self.all_function_pointer_types_.size()) {
+      self.all_function_pointer_types_.push_back(result);
+    }
+    return result;
+  }
+
+  static const std::vector<const FunctionPointerType*>&
+  AllFunctionPointerTypes() {
+    return Get().all_function_pointer_types_;
   }
 
   static const Type* GetUnionType(UnionType type) {
@@ -105,17 +113,26 @@ class TypeOracle : public ContextualClass<TypeOracle> {
   }
 
   static bool IsImplicitlyConvertableFrom(const Type* to, const Type* from) {
-    std::string name = GetGeneratedCallableName(kFromConstexprMacroName, {to});
-    return Get().declarations_->TryLookupMacro(name, {from}) != nullptr;
+    for (Generic* from_constexpr :
+         Declarations::LookupGeneric(kFromConstexprMacroName)) {
+      if (base::Optional<Callable*> specialization =
+              from_constexpr->GetSpecialization({to})) {
+        if ((*specialization)->signature().GetExplicitTypes() ==
+            TypeVector{from}) {
+          return true;
+        }
+      }
+    }
+    return false;
   }
 
  private:
   const Type* GetBuiltinType(const std::string& name) {
-    return declarations_->LookupGlobalType(name);
+    return Declarations::LookupGlobalType(name);
   }
 
-  Declarations* declarations_;
   Deduplicator<FunctionPointerType> function_pointer_types_;
+  std::vector<const FunctionPointerType*> all_function_pointer_types_;
   Deduplicator<UnionType> union_types_;
   std::vector<std::unique_ptr<Type>> nominal_types_;
   std::vector<std::unique_ptr<Type>> struct_types_;

src/torque/types.h

@@ -121,6 +121,14 @@ class Type : public TypeBase {
 
 using TypeVector = std::vector<const Type*>;
 
+inline size_t hash_value(const TypeVector& types) {
+  size_t hash = 0;
+  for (const Type* t : types) {
+    hash = base::hash_combine(hash, t);
+  }
+  return hash;
+}
+
 struct NameAndType {
   std::string name;
   const Type* type;
@@ -229,17 +237,20 @@ class FunctionPointerType final : public Type {
     return parameter_types_ == other.parameter_types_ &&
            return_type_ == other.return_type_;
   }
+  size_t function_pointer_type_id() const { return function_pointer_type_id_; }
 
  private:
   friend class TypeOracle;
   FunctionPointerType(const Type* parent, TypeVector parameter_types,
-                      const Type* return_type)
+                      const Type* return_type, size_t function_pointer_type_id)
       : Type(Kind::kFunctionPointerType, parent),
         parameter_types_(parameter_types),
-        return_type_(return_type) {}
+        return_type_(return_type),
+        function_pointer_type_id_(function_pointer_type_id) {}
 
   const TypeVector parameter_types_;
   const Type* const return_type_;
+  const size_t function_pointer_type_id_;
 };
 
 bool operator<(const Type& a, const Type& b);
@@ -460,9 +471,10 @@ std::ostream& operator<<(std::ostream& os, const ParameterTypes& parameters);
 enum class ParameterMode { kProcessImplicit, kIgnoreImplicit };
 
 struct Signature {
-  Signature(NameVector n, ParameterTypes p, size_t i, const Type* r,
-            LabelDeclarationVector l)
+  Signature(NameVector n, base::Optional<std::string> arguments_variable,
+            ParameterTypes p, size_t i, const Type* r, LabelDeclarationVector l)
       : parameter_names(std::move(n)),
+        arguments_variable(arguments_variable),
         parameter_types(std::move(p)),
         implicit_count(i),
         return_type(r),
@@ -470,6 +482,7 @@ struct Signature {
   Signature() : implicit_count(0), return_type(nullptr) {}
   const TypeVector& types() const { return parameter_types.types; }
   NameVector parameter_names;
+  base::Optional<std::string> arguments_variable;
   ParameterTypes parameter_types;
   size_t implicit_count;
   const Type* return_type;

test/torque/test-torque.tq

@@ -203,8 +203,8 @@ module test {
     check(fptr2(c, Undefined) == Undefined);
   }
 
-  type SmiToSmi = builtin(Smi) => Smi;
-  macro TestTypeAlias(x: SmiToSmi): Code {
+  type ObjectToObject = builtin(Context, Object) => Object;
+  macro TestTypeAlias(x: ObjectToObject): Code {
     return x;
   }