Fasta type inference prototype #2

pkg/kernel/lib/ast.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /// -----------------------------------------------------------------------
 ///                           ERROR HANDLING
 /// -----------------------------------------------------------------------
 ///
 /// As a rule of thumb, errors that can be detected statically are handled by
 /// the frontend, typically by translating the erroneous code into a 'throw' or
@@ skipping 1411 matching lines @@
 
   visitChildren(Visitor v) {}
   transformChildren(Transformer v) {}
 }
 
 /// Read a local variable, a local function, or a function parameter.
 class VariableGet extends Expression {
   VariableDeclaration variable;
   DartType promotedType; // Null if not promoted.
 
-  VariableGet(this.variable, [this.promotedType]);
+  VariableGet(VariableDeclaration variable, [DartType promotedType])
+      : this.forMixin(variable, promotedType);
+
+  VariableGet.forMixin(this.variable, this.promotedType);
 
   DartType getStaticType(TypeEnvironment types) {
     return promotedType ?? variable.type;
   }
 
   accept(ExpressionVisitor v) => v.visitVariableGet(this);
   accept1(ExpressionVisitor1 v, arg) => v.visitVariableGet(this, arg);
 
   visitChildren(Visitor v) {
     promotedType?.accept(v);
@@ skipping 1080 matching lines @@
       expression?.parent = this;
     }
   }
 }
 
 class ListLiteral extends Expression {
   bool isConst;
   DartType typeArgument; // Not null, defaults to DynamicType.
   final List<Expression> expressions;
 
-  ListLiteral(this.expressions,
-      {this.typeArgument: const DynamicType(), this.isConst: false}) {
+  ListLiteral(List<Expression> expressions,
+      {DartType typeArgument: const DynamicType(), bool isConst: false})
+      : this.forMixin(expressions, typeArgument, isConst);
+
+  ListLiteral.forMixin(this.expressions, this.typeArgument, this.isConst) {
     assert(typeArgument != null);
     setParents(expressions, this);
   }
 
   DartType getStaticType(TypeEnvironment types) {
     return types.literalListType(typeArgument);
   }
 
   accept(ExpressionVisitor v) => v.visitListLiteral(this);
   accept1(ExpressionVisitor1 v, arg) => v.visitListLiteral(this, arg);
@@ skipping 620 matching lines @@
     if (otherwise != null) {
       otherwise = otherwise.accept(v);
       otherwise?.parent = this;
     }
   }
 }
 
 class ReturnStatement extends Statement {
   Expression expression; // May be null.
 
-  ReturnStatement([this.expression]) {
+  ReturnStatement([Expression expression]) : this.forMixin(expression);
+
+  ReturnStatement.forMixin(this.expression) {
     expression?.parent = this;
   }
 
   accept(StatementVisitor v) => v.visitReturnStatement(this);
   accept1(StatementVisitor1 v, arg) => v.visitReturnStatement(this, arg);
 
   visitChildren(Visitor v) {
     expression?.accept(v);
   }
 
@@ skipping 168 matching lines @@
   int flags = 0;
   DartType type; // Not null, defaults to dynamic.
   InferredValue inferredValue; // May be null.
 
   /// For locals, this is the initial value.
   /// For parameters, this is the default value.
   ///
   /// Should be null in other cases.
   Expression initializer; // May be null.
 
-  VariableDeclaration(this.name,
-      {this.initializer,
-      this.type: const DynamicType(),
-      this.inferredValue,
+  VariableDeclaration(String name,
+      {Expression initializer,
+      DartType type: const DynamicType(),
+      InferredValue inferredValue,
       bool isFinal: false,
-      bool isConst: false}) {
+      bool isConst: false})
+      : this.forMixin(name, initializer, type, inferredValue, isFinal, isConst);
+
+  VariableDeclaration.forMixin(this.name, this.initializer, this.type,
+      this.inferredValue, bool isFinal, bool isConst) {
     assert(type != null);
     initializer?.parent = this;
     this.isFinal = isFinal;
     this.isConst = isConst;
   }
 
   /// Creates a synthetic variable with the given expression as initializer.
   VariableDeclaration.forValue(this.initializer,
       {bool isFinal: true,
       bool isConst: false,
@@ skipping 720 matching lines @@
 /// library has not been assigned a canonical name yet.
 ///
 /// Returns `null` if the library is `null`.
 CanonicalName getCanonicalNameOfLibrary(Library library) {
   if (library == null) return null;
   if (library.canonicalName == null) {
     throw '$library has no canonical name';
   }
   return library.canonicalName;
 }