Allocate fewer objects in dartk frontend.

pkg/kernel/lib/analyzer/ast_from_analyzer.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.
 library kernel.analyzer.ast_from_analyzer;
 
 import '../ast.dart' as ast;
 import '../frontend/accessors.dart';
 import '../frontend/super_initializers.dart';
 import '../log.dart';
 import '../type_algebra.dart';
@@ skipping 277 matching lines @@
   /// An accessor that generates a 'throw NoSuchMethodError' on both read
   /// and write access.
   Accessor unresolvedAccess(String name) {
     return new _StaticAccessor(this, name, null, null);
   }
 }
 
 class TypeScope extends ReferenceScope {
   final Map<TypeParameterElement, ast.TypeParameter> localTypeParameters =
       <TypeParameterElement, ast.TypeParameter>{};
+  TypeAnnotationBuilder _typeBuilder;
 
-  TypeScope(ReferenceLevelLoader loader) : super(loader);
+  TypeScope(ReferenceLevelLoader loader) : super(loader) {
+    _typeBuilder = new TypeAnnotationBuilder(this);
+  }
 
   String get location => '?';
 
   bool get allowClassTypeParameters => false;
 
   ast.DartType get defaultTypeParameterBound => getRootClassReference().rawType;
 
   ast.TypeParameter getTypeParameterReference(TypeParameterElement element) {
     return localTypeParameters[element] ??
         loader.tryGetClassTypeParameter(element) ??
         (localTypeParameters[element] = new ast.TypeParameter(element.name));
   }
 
   ast.TypeParameter makeTypeParameter(TypeParameterElement element,
       {ast.DartType bound}) {
     var typeParameter = getTypeParameterReference(element);
     assert(bound != null);
     typeParameter.bound = bound;
     return typeParameter;
   }
 
   ast.DartType buildType(DartType type) {
-    return new TypeAnnotationBuilder(this).buildFromDartType(type);
+    return _typeBuilder.buildFromDartType(type);
   }
 
   ast.Supertype buildSupertype(DartType type) {
     if (type is InterfaceType) {
       var classElement = type.element;
       if (classElement == null) return getRootClassReference().asRawSupertype;
       var classNode = getClassReference(classElement);
       if (classNode.typeParameters.isEmpty ||
           classNode.typeParameters.length != type.typeArguments.length) {
         return classNode.asRawSupertype;
       } else {
         return new ast.Supertype(classNode,
             type.typeArguments.map(buildType).toList(growable: false));
       }
     }
     return getRootClassReference().asRawSupertype;
   }
 
   ast.DartType buildTypeAnnotation(AstNode node) {
-    return new TypeAnnotationBuilder(this).build(node);
+    return _typeBuilder.build(node);
   }
 
   ast.DartType buildOptionalTypeAnnotation(AstNode node) {
-    return node == null ? null : new TypeAnnotationBuilder(this).build(node);
+    return node == null ? null : _typeBuilder.build(node);
   }
 
   ast.DartType getInferredType(Expression node) {
     if (!strongMode) return const ast.DynamicType();
     // TODO: Is this official way to get the strong-mode inferred type?
     return buildType(node.staticType);
   }
 
   ast.DartType getInferredTypeArgument(Expression node, int index) {
     var type = getInferredType(node);
@@ skipping 26 matching lines @@
       }
       return new List<ast.DartType>.filled(
           genericFunctionType.typeParameters.length, const ast.DynamicType());
     } else {
       return <ast.DartType>[];
     }
   }
 
   List<ast.DartType> buildOptionalTypeArgumentList(TypeArgumentList node) {
     if (node == null) return null;
-    return new TypeAnnotationBuilder(this).buildList(node.arguments);
+    return _typeBuilder.buildList(node.arguments);
   }
 
   List<ast.DartType> buildTypeArgumentList(TypeArgumentList node) {
-    return new TypeAnnotationBuilder(this).buildList(node.arguments);
+    return _typeBuilder.buildList(node.arguments);
   }
 
   List<ast.TypeParameter> buildOptionalTypeParameterList(
       TypeParameterList node) {
     if (node == null) return <ast.TypeParameter>[];
     return node.typeParameters.map(buildTypeParameter).toList();
   }
 
   ast.TypeParameter buildTypeParameter(TypeParameter node) {
     return makeTypeParameter(node.element,
@@ skipping 474 matching lines @@
   LabelStack(String label, this.next) : labels = <String>[label];
   LabelStack.unlabeled(this.next) : labels = <String>[null];
   LabelStack.switchCase(String label, this.next)
       : isSwitchTarget = true,
         labels = <String>[label];
   LabelStack.many(this.labels, this.next);
 }
 
 class StatementBuilder extends GeneralizingAstVisitor<ast.Statement> {
   final ExpressionScope scope;
-  final LabelStack breakStack, continueStack;
+  LabelStack breakStack, continueStack;
 
   StatementBuilder(this.scope, [this.breakStack, this.continueStack]);
 
   ast.Statement build(Statement node) {
     return node.accept(this);
   }
 
   ast.Statement buildOptional(Statement node) {
     return node?.accept(this);
   }
 
   ast.Statement buildInScope(
       Statement node, LabelStack breakNode, LabelStack continueNode) {
-    return new StatementBuilder(scope, breakNode, continueNode).build(node);
+    var oldBreak = this.breakStack;
+    var oldContinue = this.continueStack;
+    breakStack = breakNode;
+    continueStack = continueNode;
+    var result = build(node);
+    this.breakStack = oldBreak;
+    this.continueStack = oldContinue;
+    return result;
   }
 
   void buildBlockMember(Statement node, List<ast.Statement> output) {
     if (node is LabeledStatement &&
         node.statement is VariableDeclarationStatement) {
       // If a variable is labeled, its scope is part of the enclosing block.
       LabeledStatement labeled = node;
       node = labeled.statement;
     }
     if (node is VariableDeclarationStatement) {
@@ skipping 164 matching lines @@
         bodies.add(member.statements);
         currentCase = null;
       }
     }
     if (currentCase != null) {
       // Close off a trailing block.
       bodies.add(const <Statement>[]);
       currentCase = null;
     }
     // Now that the label environment is set up, build the bodies.
-    var innerBuilder = new StatementBuilder(scope, breakNode, continueNode);
+    var oldBreak = this.breakStack;
+    var oldContinue = this.continueStack;
+    this.breakStack = breakNode;
+    this.continueStack = continueNode;
     for (int i = 0; i < cases.length; ++i) {
       var blockNodes = <ast.Statement>[];
       for (var statement in bodies[i]) {
-        innerBuilder.buildBlockMember(statement, blockNodes);
+        buildBlockMember(statement, blockNodes);
       }
       if (blockNodes.isEmpty || !isBreakingStatement(blockNodes.last)) {
         if (i < cases.length - 1) {
           blockNodes.add(
               new ast.ExpressionStatement(scope.buildThrowFallThroughError()));
         } else {
           var jump = new ast.BreakStatement(null);
           blockNodes.add(jump);
           breakNode.jumps.add(jump);
         }
       }
       cases[i].body = new ast.Block(blockNodes)..parent = cases[i];
     }
     // Unwind the stack of case labels and bind their jumps to the case target.
-    while (continueNode != continueStack) {
+    while (continueNode != oldContinue) {
       for (var jump in continueNode.jumps) {
         (jump as ast.ContinueSwitchStatement).target =
             labelToNode[continueNode.labels.first];
       }
       continueNode = continueNode.next;
     }
     var expression = scope.buildExpression(node.expression);
     var result = new ast.SwitchStatement(expression, cases);
+    this.breakStack = oldBreak;
+    this.continueStack = oldContinue;
     return makeBreakTarget(result, breakNode);
   }
 
   ast.Statement visitForStatement(ForStatement node) {
     List<ast.VariableDeclaration> variables = <ast.VariableDeclaration>[];
     ast.Expression initialExpression;
     if (node.variables != null) {
       VariableDeclarationList list = node.variables;
       var type = scope.buildOptionalTypeAnnotation(list.type);
       for (var variable in list.variables) {
@@ skipping 143 matching lines @@
 
   @override
   visitStatement(Statement node) {
     return scope.internalError('Unhandled statement ${node.runtimeType}');
   }
 }
 
 class ExpressionBuilder
     extends GeneralizingAstVisitor /* <ast.Expression | Accessor> */ {
   final ExpressionScope scope;
-  final ast.VariableDeclaration cascadeReceiver;
-  ExpressionBuilder(this.scope, [this.cascadeReceiver]);
+  ast.VariableDeclaration cascadeReceiver;
+  ExpressionBuilder(this.scope);
 
   ast.Expression build(Expression node) {
     var result = node.accept(this);
     if (result is Accessor) {
       result = result.buildSimpleRead();
     }
     return result..fileOffset = _getOffset(node);
   }
 
   int _getOffset(AstNode node) {
@@ skipping 132 matching lines @@
     String value = node.components.map(_getTokenValue).join('.');
     return new ast.SymbolLiteral(value);
   }
 
   ast.Expression visitCascadeExpression(CascadeExpression node) {
     var receiver = build(node.target);
     // If receiver is a variable it would be tempting to reuse it, but it
     // might be reassigned in one of the cascade sections.
     var receiverVariable = new ast.VariableDeclaration.forValue(receiver,
         type: scope.getInferredType(node.target));
-    var inner = new ExpressionBuilder(scope, receiverVariable);
+    var oldReceiver = this.cascadeReceiver;
+    cascadeReceiver = receiverVariable;
     ast.Expression result = new ast.VariableGet(receiverVariable);
     for (var section in node.cascadeSections.reversed) {
-      var dummy = new ast.VariableDeclaration.forValue(inner.build(section));
+      var dummy = new ast.VariableDeclaration.forValue(build(section));
       result = new ast.Let(dummy, result);
     }
+    cascadeReceiver = oldReceiver;
     return new ast.Let(receiverVariable, result);
   }
 
   ast.Expression makeCascadeReceiver() {
     assert(cascadeReceiver != null);
     return new ast.VariableGet(cascadeReceiver);
   }
 
   ast.Expression visitConditionalExpression(ConditionalExpression node) {
     return new ast.ConditionalExpression(
@@ skipping 643 matching lines @@
             typeParameter.parent is ast.Class) {
           return const ast.InvalidType();
         }
         return new ast.TypeParameterType(typeParameter);
       } else {
         return const ast.DynamicType();
       }
     } else if (type is InterfaceType) {
       var classNode = scope.getClassReference(type.element);
       if (type.typeArguments.length == 0) {
-        return new ast.InterfaceType(classNode);
+        return classNode.rawType;
       }
       if (type.typeArguments.length != classNode.typeParameters.length) {
         log.warning('Type parameter arity error in $type');
         return const ast.InvalidType();
       }
       return new ast.InterfaceType(
           classNode, convertTypeList(type.typeArguments, boundVariables));
     } else if (type is FunctionType) {
       // TODO: Avoid infinite recursion in case of illegal circular typedef.
       boundVariables?.addAll(type.typeParameters);
@@ skipping 59 matching lines @@
       result.add(new ast.NamedType(name, convertType(type, boundVariables)));
     });
     sortAndRemoveDuplicates(result);
     return result;
   }
 
   ast.DartType visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     switch (ElementKind.of(element)) {
       case ElementKind.CLASS:
-        return new ast.InterfaceType(scope.getClassReference(element));
+        return scope.getClassReference(element).rawType;
 
       case ElementKind.DYNAMIC:
         return const ast.DynamicType();
 
       case ElementKind.FUNCTION_TYPE_ALIAS:
         FunctionTypeAliasElement functionType = element;
         return buildClosedTypeFromDartType(functionType.type);
 
       case ElementKind.TYPE_PARAMETER:
         var typeParameter = scope.getTypeParameterReference(element);
@@ skipping 246 matching lines @@
 
   /// True for the `values` field of an `enum` class.
   static bool _isValuesField(FieldElement field) => field.name == 'values';
 
   /// True for the `index` field of an `enum` class.
   static bool _isIndexField(FieldElement field) => field.name == 'index';
 
   visitEnumDeclaration(EnumDeclaration node) {
     addAnnotations(node.metadata);
     ast.Class classNode = currentClass;
-    var intType =
-        new ast.InterfaceType(scope.loader.getCoreClassReference('int'));
+    var intType = scope.loader.getCoreClassReference('int').rawType;
     var indexFieldElement = element.fields.firstWhere(_isIndexField);
     ast.Field indexField = scope.getMemberReference(indexFieldElement);
     indexField.type = intType;
     classNode.addMember(indexField);
     var parameter = new ast.VariableDeclaration('index', type: intType);
     var function = new ast.FunctionNode(new ast.EmptyStatement(),
         positionalParameters: [parameter]);
     var superConstructor = scope.loader.getRootClassConstructorReference();
     var constructor = new ast.Constructor(function,
         name: new ast.Name(''),
         isConst: true,
         initializers: [
           new ast.FieldInitializer(indexField, new ast.VariableGet(parameter)),
           new ast.SuperInitializer(superConstructor, new ast.Arguments.empty())
         ]);
     classNode.addMember(constructor);
     int index = 0;
     var enumConstantFields = <ast.Field>[];
     for (var constant in node.constants) {
       ast.Field field = scope.getMemberReference(constant.element);
       field.initializer = new ast.ConstructorInvocation(
           constructor, new ast.Arguments([new ast.IntLiteral(index)]),
           isConst: true)..parent = field;
-      field.type = new ast.InterfaceType(classNode);
+      field.type = classNode.rawType;
       classNode.addMember(field);
       ++index;
       enumConstantFields.add(field);
     }
     // Add the 'values' field.
     var valuesFieldElement = element.fields.firstWhere(_isValuesField);
     ast.Field valuesField = scope.getMemberReference(valuesFieldElement);
-    var enumType = new ast.InterfaceType(classNode);
+    var enumType = classNode.rawType;
     valuesField.type = new ast.InterfaceType(
         scope.loader.getCoreClassReference('List'), <ast.DartType>[enumType]);
     valuesField.initializer = new ast.ListLiteral(
         enumConstantFields.map(_makeStaticGet).toList(),
         isConst: true,
         typeArgument: enumType)..parent = valuesField;
     classNode.addMember(valuesField);
     // TODO: Add the toString method.
   }
 
@@ skipping 141 matching lines @@
     ast.Procedure procedure = currentMember;
     ClassElement classElement = resolutionMap
         .elementDeclaredByConstructorDeclaration(node)
         .enclosingElement;
     ast.Class classNode = procedure.enclosingClass;
     var types = getFreshTypeParameters(classNode.typeParameters);
     for (int i = 0; i < classElement.typeParameters.length; ++i) {
       scope.localTypeParameters[classElement.typeParameters[i]] =
           types.freshTypeParameters[i];
     }
+    var inferredReturnType = types.freshTypeParameters.isEmpty
+        ? classNode.rawType
+        : new ast.InterfaceType(
+            classNode,
+            types.freshTypeParameters
+                .map(makeTypeParameterType)
+                .toList(growable: false));
     var function = scope.buildFunctionNode(node.parameters, node.body,
         typeParameters: types.freshTypeParameters,
-        inferredReturnType: new ast.InterfaceType(classNode,
-            types.freshTypeParameters.map(makeTypeParameterType).toList()));
+        inferredReturnType: inferredReturnType);
     procedure.function = function..parent = procedure;
     handleNativeBody(node.body);
     if (node.redirectedConstructor != null) {
       // Redirecting factories with resolved targets don't show up here.
       assert(resolutionMap
               .elementDeclaredByConstructorDeclaration(node)
               .redirectedConstructor ==
           null);
       var function = procedure.function;
       var name = node.redirectedConstructor.type.name.name;
@@ skipping 161 matching lines @@
     if (list[i - 1].compareTo(item) == 0) {
       ++deleted;
     } else if (deleted > 0) {
       list[i - deleted] = item;
     }
   }
   if (deleted > 0) {
     list.length -= deleted;
   }
 }