Avoid eager enqueueing from resolution

pkg/compiler/lib/src/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.
 
 library dart2js.resolution.members;
 
 import '../common/names.dart' show
     Selectors;
 import '../compiler.dart' show
     Compiler;
@@ skipping 395 matching lines @@
         }
         return new ElementResult(element);
       }
       return const NoneResult();
     }
   }
 
   TypeResult visitTypeAnnotation(TypeAnnotation node) {
     DartType type = resolveTypeAnnotation(node);
     if (inCheckContext) {
-      registry.registerIsCheck(type);
+      registry.registerCheckedModeCheck(type);
     }
     return new TypeResult(type);
   }
 
   bool isNamedConstructor(Send node) => node.receiver != null;
 
   Selector getRedirectingThisOrSuperConstructorSelector(Send node) {
     if (isNamedConstructor(node)) {
       String constructorName = node.selector.asIdentifier().source;
       return new Selector.callConstructor(
@@ skipping 65 matching lines @@
     });
     addDeferredAction(enclosingElement, () {
       functionParameters.forEachOptionalParameter(
           (ParameterElementX parameter) {
         parameter.constant =
             compiler.resolver.constantCompiler.compileConstant(parameter);
       });
     });
     if (inCheckContext) {
       functionParameters.forEachParameter((ParameterElement element) {
-        registry.registerIsCheck(element.type);
+        registry.registerCheckedModeCheck(element.type);
       });
     }
   }
 
   ResolutionResult visitAssert(Assert node) {
     if (!compiler.enableAssertMessage) {
       if (node.hasMessage) {
         compiler.reportErrorMessage(
             node, MessageKind.EXPERIMENTAL_ASSERT_MESSAGE);
       }
@@ skipping 669 matching lines @@
     return const NoneResult();
   }
 
   /// Handle a type cast expression, like `a as T`.
   ResolutionResult handleAs(Send node) {
     Node expression = node.receiver;
     visitExpression(expression);
 
     Node typeNode = node.arguments.head;
     DartType type = resolveTypeAnnotation(typeNode);
-    registry.registerAsCheck(type);
+    registry.registerAsCast(type);
     registry.registerSendStructure(node, new AsStructure(type));
     return const NoneResult();
   }
 
   /// Handle the unary expression of an unresolved unary operator [text], like
   /// the no longer supported `+a`.
   ResolutionResult handleUnresolvedUnary(Send node, String text) {
     Node expression = node.receiver;
     if (node.isSuperCall) {
       checkSuperAccess(node);
@@ skipping 741 matching lines @@
           MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
           {'typeVariableName': name},
           isError: true);
       registry.registerCompileTimeError(error);
       semantics = new StaticAccess.invalid(error);
       // TODO(johnniwinther): Clean up registration of elements and selectors
       // for this case.
     } else {
       semantics = new StaticAccess.typeParameterTypeLiteral(element);
     }
-    registry.registerTypeVariableExpression(element);
 
     registry.useElement(node, element);
     registry.registerTypeLiteral(node, element.type);
 
     if (node.isCall) {
       CallStructure callStructure =
           resolveArguments(node.argumentsNode).callStructure;
       Selector selector = callStructure.callSelector;
       // TODO(23998): Remove this when all information goes through
       // the [SendStructure].
@@ skipping 32 matching lines @@
             MessageKind.IF_NULL_ASSIGNING_TYPE, const {});
         // TODO(23998): Remove these when all information goes through
         // the [SendStructure].
         registry.useElement(node.selector, element);
       } else {
         error = reportAndCreateErroneousElement(
             node.selector, name.text,
             MessageKind.ASSIGNING_TYPE, const {});
       }
 
-      if (node.isComplex) {
-        // We read the type variable before trying write to it.
-        registry.registerTypeVariableExpression(element);
-      }
-
       // TODO(23998): Remove this when all information goes through
       // the [SendStructure].
       registry.useElement(node, error);
+      // TODO(johnniwinther): Register only on read?
       registry.registerTypeLiteral(node, element.type);
       registry.registerThrowNoSuchMethod();
       semantics = new StaticAccess.typeParameterTypeLiteral(element);
     }
     return handleUpdate(node, name, semantics);
   }
 
   /// Handle access to a constant type literal of [type].
   // TODO(johnniwinther): Remove [name] when [Selector] is not required for the
   // the [GetStructure].
@@ skipping 1975 matching lines @@
         compiler, this, inConstContext: inConstContext));
   }
 
   DartType resolveTypeAnnotation(TypeAnnotation node,
                                  {bool malformedIsError: false,
                                   bool deferredIsMalformed: true}) {
     DartType type = typeResolver.resolveTypeAnnotation(
         this, node, malformedIsError: malformedIsError,
         deferredIsMalformed: deferredIsMalformed);
     if (inCheckContext) {
-      registry.registerIsCheck(type);
+      registry.registerCheckedModeCheck(type);
       registry.registerRequiredType(type, enclosingElement);
     }
     return type;
   }
 
   ResolutionResult visitLiteralList(LiteralList node) {
     bool isValidAsConstant = true;
     sendIsMemberAccess = false;
 
     NodeList arguments = node.typeArguments;
@@ skipping 19 matching lines @@
       if (node.isConst && typeArgument.containsTypeVariables) {
         compiler.reportErrorMessage(
             arguments.nodes.head,
             MessageKind.TYPE_VARIABLE_IN_CONSTANT);
         isValidAsConstant = false;
       }
       listType = coreTypes.listType(typeArgument);
     } else {
       listType = coreTypes.listType();
     }
-    registry.setType(node, listType);
-    registry.registerInstantiatedType(listType);
+    registry.registerLiteralList(
+        node,
+        listType,
+        isConstant: node.isConst,
+        isEmpty: node.elements.isEmpty);
     registry.registerRequiredType(listType, enclosingElement);
     if (node.isConst) {
       List<ConstantExpression> constantExpressions = <ConstantExpression>[];
       inConstantContext(() {
         for (Node element in node.elements) {
           ResolutionResult elementResult = visit(element);
           if (isValidAsConstant && elementResult.isConstant) {
             constantExpressions.add(elementResult.constant);
           } else {
             isValidAsConstant = false;
@@ skipping 299 matching lines @@
       mapType = coreTypes.mapType(keyTypeArgument, valueTypeArgument);
     } else {
       mapType = coreTypes.mapType();
     }
     if (node.isConst && mapType.containsTypeVariables) {
       compiler.reportErrorMessage(
           arguments,
           MessageKind.TYPE_VARIABLE_IN_CONSTANT);
       isValidAsConstant = false;
     }
-    registry.registerMapLiteral(node, mapType, node.isConst);
+    registry.registerMapLiteral(
+        node,
+        mapType,
+        isConstant: node.isConst,
+        isEmpty: node.entries.isEmpty);
     registry.registerRequiredType(mapType, enclosingElement);
     if (node.isConst) {
 
       List<ConstantExpression> keyExpressions = <ConstantExpression>[];
       List<ConstantExpression> valueExpressions = <ConstantExpression>[];
       inConstantContext(() {
         for (LiteralMapEntry entry in node.entries) {
           ResolutionResult keyResult = visit(entry.key);
           ResolutionResult valueResult = visit(entry.value);
           if (isValidAsConstant &&
@@ skipping 306 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }