[torque] add type alias declarations

Change-Id: I80dd313ac3a5809d363adff9cf11ac31b04648dd
Reviewed-on: https://chromium-review.googlesource.com/1068876
Commit-Queue: Tobias Tebbi <tebbi@chromium.org>
Reviewed-by: Sigurd Schneider <sigurds@chromium.org>
Cr-Commit-Position: refs/heads/master@{#53292}

src/torque/Torque.g4

@@ -270,6 +270,7 @@ extendsDeclaration: 'extends' IDENTIFIER;
 generatesDeclaration: 'generates' STRING_LITERAL;
 constexprDeclaration: 'constexpr' STRING_LITERAL;
 typeDeclaration : 'type' IDENTIFIER extendsDeclaration? generatesDeclaration? constexprDeclaration?';';
+typeAliasDeclaration : 'type' IDENTIFIER '=' type ';';
 
 externalBuiltin : EXTERN JAVASCRIPT? BUILTIN IDENTIFIER optionalGenericTypeList '(' typeList ')' optionalType ';';
 externalMacro : EXTERN (IMPLICIT? 'operator' STRING_LITERAL)? MACRO IDENTIFIER optionalGenericTypeList typeListMaybeVarArgs optionalType optionalLabelList ';';
@@ -281,6 +282,7 @@ constDeclaration : 'const' IDENTIFIER ':' type '=' STRING_LITERAL ';';
 
 declaration
         : typeDeclaration
+        | typeAliasDeclaration
         | builtinDeclaration
         | genericSpecialization
         | macroDeclaration

src/torque/TorqueBaseListener.h

@@ -281,6 +281,11 @@ class TorqueBaseListener : public TorqueListener {
   void exitTypeDeclaration(
       TorqueParser::TypeDeclarationContext* /*ctx*/) override {}
 
+  void enterTypeAliasDeclaration(
+      TorqueParser::TypeAliasDeclarationContext* /*ctx*/) override {}
+  void exitTypeAliasDeclaration(
+      TorqueParser::TypeAliasDeclarationContext* /*ctx*/) override {}
+
   void enterExternalBuiltin(
       TorqueParser::ExternalBuiltinContext* /*ctx*/) override {}
   void exitExternalBuiltin(

src/torque/TorqueBaseVisitor.h

@@ -300,6 +300,11 @@ class TorqueBaseVisitor : public TorqueVisitor {
     return visitChildren(ctx);
   }
 
+  antlrcpp::Any visitTypeAliasDeclaration(
+      TorqueParser::TypeAliasDeclarationContext* ctx) override {
+    return visitChildren(ctx);
+  }
+
   antlrcpp::Any visitExternalBuiltin(
       TorqueParser::ExternalBuiltinContext* ctx) override {
     return visitChildren(ctx);

src/torque/TorqueListener.h

@@ -266,6 +266,11 @@ class TorqueListener : public antlr4::tree::ParseTreeListener {
   virtual void exitTypeDeclaration(
       TorqueParser::TypeDeclarationContext* ctx) = 0;
 
+  virtual void enterTypeAliasDeclaration(
+      TorqueParser::TypeAliasDeclarationContext* ctx) = 0;
+  virtual void exitTypeAliasDeclaration(
+      TorqueParser::TypeAliasDeclarationContext* ctx) = 0;
+
   virtual void enterExternalBuiltin(
       TorqueParser::ExternalBuiltinContext* ctx) = 0;
   virtual void exitExternalBuiltin(

src/torque/TorqueParser.h

@@ -158,16 +158,17 @@ class TorqueParser : public antlr4::Parser {
     RuleGeneratesDeclaration = 56,
     RuleConstexprDeclaration = 57,
     RuleTypeDeclaration = 58,
-    RuleExternalBuiltin = 59,
-    RuleExternalMacro = 60,
-    RuleExternalRuntime = 61,
-    RuleBuiltinDeclaration = 62,
-    RuleGenericSpecialization = 63,
-    RuleMacroDeclaration = 64,
-    RuleConstDeclaration = 65,
-    RuleDeclaration = 66,
-    RuleModuleDeclaration = 67,
-    RuleFile = 68
+    RuleTypeAliasDeclaration = 59,
+    RuleExternalBuiltin = 60,
+    RuleExternalMacro = 61,
+    RuleExternalRuntime = 62,
+    RuleBuiltinDeclaration = 63,
+    RuleGenericSpecialization = 64,
+    RuleMacroDeclaration = 65,
+    RuleConstDeclaration = 66,
+    RuleDeclaration = 67,
+    RuleModuleDeclaration = 68,
+    RuleFile = 69
   };
 
   explicit TorqueParser(antlr4::TokenStream* input);
@@ -240,6 +241,7 @@ class TorqueParser : public antlr4::Parser {
   class GeneratesDeclarationContext;
   class ConstexprDeclarationContext;
   class TypeDeclarationContext;
+  class TypeAliasDeclarationContext;
   class ExternalBuiltinContext;
   class ExternalMacroContext;
   class ExternalRuntimeContext;
@@ -1260,6 +1262,22 @@ class TorqueParser : public antlr4::Parser {
 
   TypeDeclarationContext* typeDeclaration();
 
+  class TypeAliasDeclarationContext : public antlr4::ParserRuleContext {
+   public:
+    TypeAliasDeclarationContext(antlr4::ParserRuleContext* parent,
+                                size_t invokingState);
+    size_t getRuleIndex() const override;
+    antlr4::tree::TerminalNode* IDENTIFIER();
+    TypeContext* type();
+
+    void enterRule(antlr4::tree::ParseTreeListener* listener) override;
+    void exitRule(antlr4::tree::ParseTreeListener* listener) override;
+
+    antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor) override;
+  };
+
+  TypeAliasDeclarationContext* typeAliasDeclaration();
+
   class ExternalBuiltinContext : public antlr4::ParserRuleContext {
    public:
     ExternalBuiltinContext(antlr4::ParserRuleContext* parent,
@@ -1407,6 +1425,7 @@ class TorqueParser : public antlr4::Parser {
     DeclarationContext(antlr4::ParserRuleContext* parent, size_t invokingState);
     size_t getRuleIndex() const override;
     TypeDeclarationContext* typeDeclaration();
+    TypeAliasDeclarationContext* typeAliasDeclaration();
     BuiltinDeclarationContext* builtinDeclaration();
     GenericSpecializationContext* genericSpecialization();
     MacroDeclarationContext* macroDeclaration();

src/torque/TorqueVisitor.h

@@ -195,6 +195,9 @@ class TorqueVisitor : public antlr4::tree::AbstractParseTreeVisitor {
   virtual antlrcpp::Any visitTypeDeclaration(
       TorqueParser::TypeDeclarationContext* context) = 0;
 
+  virtual antlrcpp::Any visitTypeAliasDeclaration(
+      TorqueParser::TypeAliasDeclarationContext* context) = 0;
+
   virtual antlrcpp::Any visitExternalBuiltin(
       TorqueParser::ExternalBuiltinContext* context) = 0;
 

src/torque/ast-generator.cc

@@ -308,6 +308,14 @@ antlrcpp::Any AstGenerator::visitTypeDeclaration(
   return implicit_cast<Declaration*>(result);
 }
 
+antlrcpp::Any AstGenerator::visitTypeAliasDeclaration(
+    TorqueParser::TypeAliasDeclarationContext* context) {
+  TypeAliasDeclaration* result = RegisterNode(new TypeAliasDeclaration{
+      Pos(context), context->IDENTIFIER()->getSymbol()->getText(),
+      GetType(context->type())});
+  return implicit_cast<Declaration*>(result);
+}
+
 antlrcpp::Any AstGenerator::visitVariableDeclaration(
     TorqueParser::VariableDeclarationContext* context) {
   return RegisterNode(

src/torque/ast-generator.h

@@ -50,6 +50,9 @@ class AstGenerator : public TorqueBaseVisitor {
   antlrcpp::Any visitTypeDeclaration(
       TorqueParser::TypeDeclarationContext* context) override;
 
+  antlrcpp::Any visitTypeAliasDeclaration(
+      TorqueParser::TypeAliasDeclarationContext* context) override;
+
   antlrcpp::Any visitVariableDeclaration(
       TorqueParser::VariableDeclarationContext* context) override;
 

src/torque/ast.h

@@ -65,6 +65,7 @@ DECLARE_CONTEXTUAL_VARIABLE(CurrentSourcePosition, SourcePosition)
 
 #define AST_DECLARATION_NODE_KIND_LIST(V) \
   V(TypeDeclaration)                      \
+  V(TypeAliasDeclaration)                 \
   V(StandardDeclaration)                  \
   V(GenericDeclaration)                   \
   V(SpecializationDeclaration)            \
@@ -553,6 +554,14 @@ struct TypeDeclaration : Declaration {
   base::Optional<std::string> constexpr_generates;
 };
 
+struct TypeAliasDeclaration : Declaration {
+  DEFINE_AST_NODE_LEAF_BOILERPLATE(TypeAliasDeclaration)
+  TypeAliasDeclaration(SourcePosition p, std::string n, TypeExpression* t)
+      : Declaration(kKind, p), name(std::move(n)), type(t) {}
+  std::string name;
+  TypeExpression* type;
+};
+
 struct LabelAndTypes {
   std::string name;
   std::vector<TypeExpression*> types;

src/torque/declaration-visitor.h

@@ -84,6 +84,11 @@ class DeclarationVisitor : public FileVisitor {
     }
   }
 
+  void Visit(TypeAliasDeclaration* decl) {
+    declarations()->DeclareType(decl->name,
+                                declarations()->GetType(decl->type));
+  }
+
   Builtin* BuiltinDeclarationCommon(BuiltinDeclaration* decl, bool external,
                                     const Signature& signature);
 

src/torque/implementation-visitor.h

@@ -94,6 +94,7 @@ class ImplementationVisitor : public FileVisitor {
     Visit(implicit_cast<ModuleDeclaration*>(decl));
   }
   void Visit(TypeDeclaration* decl) {}
+  void Visit(TypeAliasDeclaration* decl) {}
   void Visit(ConstDeclaration* decl) {}
   void Visit(StandardDeclaration* decl);
   void Visit(GenericDeclaration* decl) {}

test/torque/test-torque.tq

@@ -189,4 +189,9 @@ module test {
     assert(fptr2(c, Undefined) == Undefined);
     assert(fptr2(c, Undefined) == Undefined);
   }
+
+  type SmiToSmi = builtin(Smi) => Smi;
+  macro TestTypeAlias(x : SmiToSmi) : Code {
+    return x;
+  }
 }