Add TypeUse.

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.dart';
 import '../common/names.dart' show
     Selectors;
 import '../compiler.dart' show
@@ skipping 21 matching lines @@
     isUserDefinableOperator;
 import '../tree/tree.dart';
 import '../util/util.dart' show
     Link;
 import '../universe/call_structure.dart' show
     CallStructure;
 import '../universe/selector.dart' show
     Selector;
 import '../universe/use.dart' show
     DynamicUse,
-    StaticUse;
+    StaticUse,
+    TypeUse;
 
 import 'access_semantics.dart';
 import 'class_members.dart' show MembersCreator;
 import 'operators.dart';
 import 'send_structure.dart';
 
 import 'constructors.dart' show
     ConstructorResolver,
     ConstructorResult;
 import 'label_scope.dart' show
@@ skipping 341 matching lines @@
         }
         return new ElementResult(element);
       }
       return const NoneResult();
     }
   }
 
   TypeResult visitTypeAnnotation(TypeAnnotation node) {
     DartType type = resolveTypeAnnotation(node);
     if (inCheckContext) {
-      registry.registerCheckedModeCheck(type);
+      registry.registerTypeUse(new TypeUse.checkedModeCheck(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.registerCheckedModeCheck(element.type);
+        registry.registerTypeUse(new TypeUse.checkedModeCheck(element.type));
       });
     }
   }
 
   ResolutionResult visitAssert(Assert node) {
     if (!compiler.enableAssertMessage) {
       if (node.hasMessage) {
         reporter.reportErrorMessage(
             node, MessageKind.EXPERIMENTAL_ASSERT_MESSAGE);
       }
@@ skipping 654 matching lines @@
       // `e is! T`.
       Node typeNode = notTypeNode.receiver;
       type = resolveTypeAnnotation(typeNode);
       sendStructure = new IsNotStructure(type);
     } else {
       // `e is T`.
       Node typeNode = node.arguments.head;
       type = resolveTypeAnnotation(typeNode);
       sendStructure = new IsStructure(type);
     }
-    registry.registerIsCheck(type);
+    registry.registerTypeUse(new TypeUse.isCheck(type));
     registry.registerSendStructure(node, sendStructure);
     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.registerAsCast(type);
+    registry.registerTypeUse(new TypeUse.asCast(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 2363 matching lines @@
     } else if (node.receiver == null) {
       // `a = c`
       return handleUnqualifiedSendSet(node);
     } else {
       // `a.b = c`
       return handleQualifiedSendSet(node);
     }
   }
 
   ConstantResult visitLiteralInt(LiteralInt node) {
-    registry.registerInstantiatedType(coreTypes.intType);
+    // TODO(johnniwinther): Make this a feature instead.
+    registry.registerTypeUse(new TypeUse.instantiation(coreTypes.intType));
     ConstantExpression constant = new IntConstantExpression(node.value);
     registry.setConstant(node, constant);
     return new ConstantResult(node, constant);
   }
 
   ConstantResult visitLiteralDouble(LiteralDouble node) {
-    registry.registerInstantiatedType(coreTypes.doubleType);
+    // TODO(johnniwinther): Make this a feature instead.
+    registry.registerTypeUse(new TypeUse.instantiation(coreTypes.doubleType));
     ConstantExpression constant = new DoubleConstantExpression(node.value);
     registry.setConstant(node, constant);
     return new ConstantResult(node, constant);
   }
 
   ConstantResult visitLiteralBool(LiteralBool node) {
-    registry.registerInstantiatedType(coreTypes.boolType);
+    // TODO(johnniwinther): Make this a feature instead.
+    registry.registerTypeUse(new TypeUse.instantiation(coreTypes.boolType));
     ConstantExpression constant = new BoolConstantExpression(node.value);
     registry.setConstant(node, constant);
     return new ConstantResult(node, constant);
   }
 
   ResolutionResult visitLiteralString(LiteralString node) {
-    registry.registerInstantiatedType(coreTypes.stringType);
+    // TODO(johnniwinther): Make this a feature instead.
+    registry.registerTypeUse(new TypeUse.instantiation(coreTypes.stringType));
     if (node.dartString != null) {
       // [dartString] might be null on parser errors.
       ConstantExpression constant =
           new StringConstantExpression(node.dartString.slowToString());
       registry.setConstant(node, constant);
       return new ConstantResult(node, constant);
     }
     return const NoneResult();
   }
 
   ConstantResult visitLiteralNull(LiteralNull node) {
-    registry.registerInstantiatedType(coreTypes.nullType);
+    registry.registerTypeUse(new TypeUse.instantiation(coreTypes.nullType));
     ConstantExpression constant = new NullConstantExpression();
     registry.setConstant(node, constant);
     return new ConstantResult(node, constant);
   }
 
   ConstantResult visitLiteralSymbol(LiteralSymbol node) {
+    // TODO(johnniwinther): Make this a feature instead.
     String name = node.slowNameString;
     registry.registerConstSymbol(name);
     if (!validateSymbol(node, name, reportError: false)) {
       reporter.reportErrorMessage(
           node,
           MessageKind.UNSUPPORTED_LITERAL_SYMBOL,
           {'value': name});
     }
     analyzeConstantDeferred(node);
     ConstantExpression constant = new SymbolConstantExpression(name);
     registry.setConstant(node, constant);
     return new ConstantResult(node, constant);
   }
 
   ResolutionResult visitStringJuxtaposition(StringJuxtaposition node) {
-    registry.registerInstantiatedType(coreTypes.stringType);
+    // TODO(johnniwinther): Make this a feature instead.
+    registry.registerTypeUse(new TypeUse.instantiation(coreTypes.stringType));
     ResolutionResult first = visit(node.first);
     ResolutionResult second = visit(node.second);
     if (first.isConstant && second.isConstant) {
       ConstantExpression constant = new ConcatenateConstantExpression(
           <ConstantExpression>[first.constant, second.constant]);
       registry.setConstant(node, constant);
       return new ConstantResult(node, constant);
     }
     return const NoneResult();
   }
@@ skipping 113 matching lines @@
     }
 
     // Register a post process to check for cycles in the redirection chain and
     // set the actual generative constructor at the end of the chain.
     addDeferredAction(constructor, () {
       compiler.resolver.resolveRedirectionChain(constructor, node);
     });
 
     registry.registerStaticUse(
         new StaticUse.constructorRedirect(redirectionTarget));
-    // TODO(johnniwinther): Register the effective target type instead.
-    registry.registerInstantiatedType(
+    // TODO(johnniwinther): Register the effective target type as part of the
+    // static use instead.
+    registry.registerTypeUse(new TypeUse.instantiation(
         redirectionTarget.enclosingClass.thisType
-            .subst(type.typeArguments, targetClass.typeVariables));
+            .subst(type.typeArguments, targetClass.typeVariables)));
     if (isSymbolConstructor) {
       registry.registerSymbolConstructor();
     }
     if (isValidAsConstant) {
       List<String> names = <String>[];
       List<ConstantExpression> arguments = <ConstantExpression>[];
       int index = 0;
       constructorSignature.forEachParameter((ParameterElement parameter) {
         if (parameter.isNamed) {
           String name = parameter.name;
@@ skipping 140 matching lines @@
 
     InterfaceType type = registry.getType(node);
     if (node.isConst && type.containsTypeVariables) {
       reporter.reportErrorMessage(
           node.send.selector,
           MessageKind.TYPE_VARIABLE_IN_CONSTANT);
       isValidAsConstant = false;
     }
     // TODO(johniwinther): Avoid registration of `type` in face of redirecting
     // factory constructors.
-    registry.registerInstantiatedType(type);
+    registry.registerTypeUse(new TypeUse.instantiation(type));
     if (constructor.isGenerativeConstructor && cls.isAbstract) {
       isValidAsConstant = false;
     }
 
     if (isSymbolConstructor) {
       if (node.isConst) {
         Node argumentNode = node.send.arguments.head;
         ConstantExpression constant =
             compiler.resolver.constantCompiler.compileNode(
                 argumentNode, registry.mapping);
@@ skipping 132 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.registerCheckedModeCheck(type);
+      registry.registerTypeUse(new TypeUse.checkedModeCheck(type));
     }
     return type;
   }
 
   ResolutionResult visitLiteralList(LiteralList node) {
     bool isValidAsConstant = true;
     sendIsMemberAccess = false;
 
     NodeList arguments = node.typeArguments;
     DartType typeArgument;
@@ skipping 71 matching lines @@
           conditionResult.constant,
           thenResult.constant,
           elseResult.constant);
       registry.setConstant(node, constant);
       return new ConstantResult(node, constant);
     }
     return const NoneResult();
   }
 
   ResolutionResult visitStringInterpolation(StringInterpolation node) {
-    registry.registerInstantiatedType(coreTypes.stringType);
+    // TODO(johnniwinther): The should be a consequence of the registration below.

[sigurdm, 2015/11/04 10:37:31]

Sentence is broken. Long line.

[Johnni Winther, 2015/11/04 13:41:09]

Done.

+    registry.registerTypeUse(new TypeUse.instantiation(coreTypes.stringType));
     registry.registerStringInterpolation();
     registerImplicitInvocation(Selectors.toString_);
 
     bool isValidAsConstant = true;
     List<ConstantExpression> parts = <ConstantExpression>[];
 
     void resolvePart(Node subnode) {
       ResolutionResult result = visit(subnode);
       if (isValidAsConstant && result.isConstant) {
         parts.add(result.constant);
@@ skipping 565 matching lines @@
     inCatchBlock = oldInCatchBlock;
 
     if (exceptionTypeResult != null) {
       DartType exceptionType = exceptionTypeResult.type;
       if (exceptionDefinition != null) {
         Node exceptionVariable = exceptionDefinition.definitions.nodes.head;
         VariableElementX exceptionElement =
             registry.getDefinition(exceptionVariable);
         exceptionElement.variables.type = exceptionType;
       }
-      registry.registerOnCatchType(exceptionType);
+      registry.registerTypeUse(new TypeUse.catchType(exceptionType));
     }
     if (stackTraceDefinition != null) {
       Node stackTraceVariable = stackTraceDefinition.definitions.nodes.head;
       VariableElementX stackTraceElement =
           registry.getDefinition(stackTraceVariable);
       InterfaceType stackTraceType = coreTypes.stackTraceType;
       stackTraceElement.variables.type = stackTraceType;
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(DiagnosticReporter reporter, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), reporter, node);
 }