[dart2dart] Optionally cut types in variable declarations:

lib/compiler/implementation/dart_backend/placeholder_collector.dart

 // Copyright (c) 2012, 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.
 
 class LocalPlaceholder implements Hashable {
   final String identifier;
   final Set<Node> nodes;
   LocalPlaceholder(this.identifier) : nodes = new Set<Node>();
   int hashCode() => identifier.hashCode();
   String toString() =>
       'local_placeholder[id($identifier), nodes($nodes)]';
 }
 
 class FunctionScope {
   final Set<String> parameterIdentifiers;
   final Set<LocalPlaceholder> localPlaceholders;
   FunctionScope()
       : parameterIdentifiers = new Set<String>(),
       localPlaceholders = new Set<LocalPlaceholder>();
   void registerParameter(Identifier node) {
     parameterIdentifiers.add(node.source.slowToString());
   }
 }
 
+class DeclarationTypePlaceholder {
+  final TypeAnnotation typeNode;
+  final bool requiresVar;
+  DeclarationTypePlaceholder(this.typeNode, this.requiresVar);
+}
+
 class SendVisitor extends ResolvedVisitor {
   final PlaceholderCollector collector;
 
   SendVisitor(this.collector, TreeElements elements) : super(elements);
 
   visitDynamicSend(Send node) {}
   visitSuperSend(Send node) {}
   visitOperatorSend(Send node) {}
   visitForeignSend(Send node) {}
 
@@ skipping 43 matching lines @@
   }
 }
 
 class PlaceholderCollector extends AbstractVisitor {
   final Compiler compiler;
   final Set<Node> nullNodes;  // Nodes that should not be in output.
   final Set<Identifier> unresolvedNodes;
   final Map<Element, Set<Node>> elementNodes;
   final Map<FunctionElement, FunctionScope> functionScopes;
   final Map<LibraryElement, Set<Identifier>> privateNodes;
+  final List<DeclarationTypePlaceholder> declarationTypePlaceholders;
   Map<String, LocalPlaceholder> currentLocalPlaceholders;
   Element currentElement;
   TreeElements treeElements;
 
   LibraryElement get coreLibrary => compiler.coreLibrary;
   FunctionElement get entryFunction => compiler.mainApp.find(Compiler.MAIN);
 
   PlaceholderCollector(this.compiler) :
       nullNodes = new Set<Node>(),
       unresolvedNodes = new Set<Identifier>(),
       elementNodes = new Map<Element, Set<Node>>(),
       functionScopes = new Map<FunctionElement, FunctionScope>(),
-      privateNodes = new Map<LibraryElement, Set<Identifier>>();
+      privateNodes = new Map<LibraryElement, Set<Identifier>>(),
+      declarationTypePlaceholders = new List<DeclarationTypePlaceholder>();
 
   void tryMakeConstructorNamePlaceholder(
       FunctionExpression constructor, ClassElement element) {
     Node nameNode = constructor.name;
     if (nameNode is Send) nameNode = nameNode.receiver;
     if (nameNode.asIdentifier().token.slowToString()
         == element.name.slowToString()) {
       makeElementPlaceholder(nameNode, element);
     }
   }
@@ skipping 46 matching lines @@
     if (Elements.isStaticOrTopLevel(element)) {
       Node fieldNode = element.parseNode(compiler);
       if (fieldNode is Identifier) {
         makeElementPlaceholder(fieldNode, element);
       } else if (fieldNode is SendSet) {
         makeElementPlaceholder(fieldNode.selector, element);
       } else {
         unreachable();
       }
     }
+    makeVarDeclarationTypePlaceholder(node);
   }
 
   void collect(Element element, TreeElements elements) {
     treeElements = elements;
     Node elementNode;
     if (element is FunctionElement) {
       currentElement = element;
       elementNode = currentElement.parseNode(compiler);
       collectFunctionDeclarationPlaceholders(element, elementNode);
     } else if (element.isField()) {
@@ skipping 33 matching lines @@
           .registerParameter(node);
     } else if (Elements.isLocal(element)) {
       makeLocalPlaceholder(node);
     }
   }
 
   void makeTypePlaceholder(Node node, Type type) {
     makeElementPlaceholder(node, type.element);
   }
 
+  void makeOmitDeclarationTypePlaceholder(TypeAnnotation type) {
+    if (type === null) return;
+    declarationTypePlaceholders.add(
+        new DeclarationTypePlaceholder(type, false));
+  }
+
+  void makeVarDeclarationTypePlaceholder(VariableDefinitions node) {
+    // TODO(smok): Maybe instead of calling this method and
+    // makeDeclaratioTypePlaceholder have type declaration placeholder
+    // collector logic in visitVariableDefinitions when resolver becomes better
+    // and/or catch syntax changes.
+    if (node.type === null) return;
+    Element definitionElement = treeElements[node.definitions.nodes.head];
+    bool requiresVar = !node.modifiers.isFinalOrConst();
+    declarationTypePlaceholders.add(
+        new DeclarationTypePlaceholder(node.type, requiresVar));
+  }
+
   void makeNullPlaceholder(Node node) {
     assert(node is Identifier || node is Send);
     nullNodes.add(node);
   }
 
   void makeElementPlaceholder(Node node, Element element) {
     assert(element !== null);
     if (element === entryFunction) return;
     if (element.getLibrary() === coreLibrary) return;
     if (isDartCoreLib(compiler, element.getLibrary())
@@ skipping 154 matching lines @@
     if (element !== null) {
       // Rename only local functions.
       if (element !== currentElement) {
         if (node.name !== null) {
           assert(node.name is Identifier);
           tryMakeLocalPlaceholder(element, node.name);
         }
       }
     }
     node.visitChildren(this);
+    makeOmitDeclarationTypePlaceholder(node.returnType);
+    collectFunctionParameters(node.parameters);
+  }
+
+  void collectFunctionParameters(NodeList parameters) {
+    if (parameters === null) return;
+    for (Node parameter in parameters.nodes) {
+      if (parameter is NodeList) {
+        // Optional parameter list.
+        collectFunctionParameters(parameter);
+      } else {
+        assert(parameter is VariableDefinitions);
+        makeOmitDeclarationTypePlaceholder(
+            parameter.asVariableDefinitions().type);
+      }
+    }
   }
 
   visitClassNode(ClassNode node) {
     ClassElement classElement = currentElement;
     makeElementPlaceholder(node.name, classElement);
     node.visitChildren(this);
     if (node.defaultClause !== null) {
       // Can't just visit class node's default clause because of the bug in the
       // resolver, it just crashes when it meets type variable.
       Type defaultType = classElement.defaultClass;
@@ skipping 28 matching lines @@
   visitTypeVariable(TypeVariable node) {
     assert(currentElement is TypedefElement || currentElement is ClassElement);
     tryResolveAndCollectTypeVariable(currentElement, node.name);
     node.visitChildren(this);
   }
 
   visitTypedef(Typedef node) {
     assert(currentElement is TypedefElement);
     makeElementPlaceholder(node.name, currentElement);
     node.visitChildren(this);
+    makeOmitDeclarationTypePlaceholder(node.returnType);
+    collectFunctionParameters(node.formals);
+  }
+
+  visitBlock(Block node) {
+    for (Node statement in node.statements.nodes) {
+      if (statement is VariableDefinitions) {
+        makeVarDeclarationTypePlaceholder(statement);
+      }
+    }
+    node.visitChildren(this);
   }
 }