Create type masks lazily.

sdk/lib/_internal/compiler/implementation/resolution/members.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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Set<Node> get superUses;
 
   /// A set of additional dependencies.  See [registerDependency] below.
   Set<Element> get otherDependencies;
 
   Element operator[](Node node);
   Selector getSelector(Send send);
   Selector getGetterSelectorInComplexSendSet(SendSet node);
   Selector getOperatorSelectorInComplexSendSet(SendSet node);
   DartType getType(Node node);
   void setSelector(Node node, Selector selector);
   void setGetterSelectorInComplexSendSet(SendSet node, Selector selector);
   void setOperatorSelectorInComplexSendSet(SendSet node, Selector selector);
   Selector getIteratorSelector(ForIn node);
   Selector getMoveNextSelector(ForIn node);
   Selector getCurrentSelector(ForIn node);
   Selector setIteratorSelector(ForIn node, Selector selector);
   Selector setMoveNextSelector(ForIn node, Selector selector);
   Selector setCurrentSelector(ForIn node, Selector selector);
 
+  /**
+   * Returns [:true:] if [node] is a type literal.
+   *
+   * Resolution marks this by setting the type on the node to be the
+   * [:Type:] type.
+   */
+  bool isTypeLiteral(Send node);
+
   /// Register additional dependencies required by [currentElement].
   /// For example, elements that are used by a backend.
   void registerDependency(Element element);
 }
 
 class TreeElementMapping implements TreeElements {
   final Element currentElement;
   final Map<Spannable, Selector> selectors =
       new LinkedHashMap<Spannable, Selector>();
   final Map<Node, DartType> types = new LinkedHashMap<Node, DartType>();
@@ skipping 86 matching lines @@
   }
 
   Selector setCurrentSelector(ForIn node, Selector selector) {
     selectors[node.inToken] = selector;
   }
 
   Selector getCurrentSelector(ForIn node) {
     return selectors[node.inToken];
   }
 
+  bool isTypeLiteral(Send node) {
+    return getType(node) != null;
+  }
+
   void registerDependency(Element element) {
     otherDependencies.add(element.implementation);
   }
 
   String toString() => 'TreeElementMapping($currentElement)';
 }
 
 class ResolverTask extends CompilerTask {
   ResolverTask(Compiler compiler) : super(compiler);
 
@@ skipping 2158 matching lines @@
                                             MessageKind.CANNOT_RESOLVE_GETTER);
         }
       } else if (target.isTypeVariable()) {
         ClassElement cls = target.getEnclosingClass();
         assert(enclosingElement.getEnclosingClass() == cls);
         compiler.backend.registerClassUsingVariableExpression(cls);
         compiler.backend.registerTypeVariableExpression(mapping);
         // Set the type of the node to [Type] to mark this send as a
         // type variable expression.
         mapping.setType(node, compiler.typeClass.computeType(compiler));
-        world.registerInstantiatedClass(compiler.typeClass, mapping);
+        world.registerTypeLiteral(target, mapping);
       } else if (target.impliesType() && !sendIsMemberAccess) {
         // Set the type of the node to [Type] to mark this send as a
         // type literal.
         mapping.setType(node, compiler.typeClass.computeType(compiler));
         world.registerTypeLiteral(target, mapping);
       }
     }
 
     bool resolvedArguments = false;
     if (node.isOperator) {
@@ skipping 143 matching lines @@
 
       // Make sure we include the + and - operators if we are using
       // the ++ and -- ones.  Also, if op= form is used, include op itself.
       void registerBinaryOperator(SourceString name) {
         Selector binop = new Selector.binaryOperator(name);
         world.registerDynamicInvocation(binop);
         mapping.setOperatorSelectorInComplexSendSet(node, binop);
       }
       if (identical(source, '++')) {
         registerBinaryOperator(const SourceString('+'));
+        world.registerInstantiatedClass(compiler.intClass, mapping);
       } else if (identical(source, '--')) {
         registerBinaryOperator(const SourceString('-'));
+        world.registerInstantiatedClass(compiler.intClass, mapping);
       } else if (source.endsWith('=')) {
         registerBinaryOperator(Elements.mapToUserOperator(operatorName));
       }
     }
 
     registerSend(selector, setter);
     return useElement(node, setter);
   }
 
   void registerSend(Selector selector, Element target) {
@@ skipping 1661 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }