Remove requiredTypes

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 621 matching lines @@
     // Run the body in a fresh statement scope.
     StatementScope oldStatementScope = statementScope;
     statementScope = new StatementScope();
     visit(node.body);
     statementScope = oldStatementScope;
 
     scope = oldScope;
     enclosingElement = previousEnclosingElement;
 
     registry.registerClosure(function);
-    registry.registerInstantiatedClass(compiler.functionClass);
     return const NoneResult();
   }
 
   ResolutionResult visitIf(If node) {
     doInPromotionScope(node.condition.expression, () => visit(node.condition));
     doInPromotionScope(node.thenPart,
         () => visitIn(node.thenPart, new BlockScope(scope)));
     visitIn(node.elsePart, new BlockScope(scope));
     return const NoneResult();
   }
@@ skipping 2872 matching lines @@
   }
 
   ConstantResult visitLiteralNull(LiteralNull node) {
     registry.registerInstantiatedType(coreTypes.nullType);
     ConstantExpression constant = new NullConstantExpression();
     registry.setConstant(node, constant);
     return new ConstantResult(node, constant);
   }
 
   ConstantResult visitLiteralSymbol(LiteralSymbol node) {
-    registry.registerInstantiatedClass(compiler.symbolClass);
-    registry.registerStaticUse(compiler.symbolConstructor.declaration);
     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);
@@ skipping 96 matching lines @@
         // TODO(johnniwinther): Create constant constructor for this case and
         // let evaluation detect the cyclicity.
         isValidAsConstant = false;
       }
     }
 
     // Check that the target constructor is type compatible with the
     // redirecting constructor.
     ClassElement targetClass = redirectionTarget.enclosingClass;
     InterfaceType type = registry.getType(node);
-    FunctionType targetType = redirectionTarget.computeType(resolution)
-        .subst(type.typeArguments, targetClass.typeVariables);
+    FunctionType targetConstructorType =
+        redirectionTarget.computeType(resolution)
+            .subst(type.typeArguments, targetClass.typeVariables);
     FunctionType constructorType = constructor.computeType(resolution);
-    bool isSubtype = compiler.types.isSubtype(targetType, constructorType);
+    bool isSubtype = compiler.types.isSubtype(
+        targetConstructorType, constructorType);
     if (!isSubtype) {
       reporter.reportWarningMessage(
           node,
           MessageKind.NOT_ASSIGNABLE,
-          {'fromType': targetType, 'toType': constructorType});
+          {'fromType': targetConstructorType, 'toType': constructorType});
       // TODO(johnniwinther): Handle this (potentially) erroneous case.
       isValidAsConstant = false;
     }
 
     redirectionTarget.computeType(resolution);
     FunctionSignature targetSignature = redirectionTarget.functionSignature;
     constructor.computeType(resolution);
     FunctionSignature constructorSignature = constructor.functionSignature;
     if (!targetSignature.isCompatibleWith(constructorSignature)) {
       assert(!isSubtype);
       registry.registerThrowNoSuchMethod();
       isValidAsConstant = false;
     }
 
     // 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(redirectionTarget);
     // TODO(johnniwinther): Register the effective target type instead.
-    registry.registerInstantiatedClass(
-        redirectionTarget.enclosingClass.declaration);
+    registry.registerInstantiatedType(
+        redirectionTarget.enclosingClass.thisType
+            .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 292 matching lines @@
   }
 
   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.registerRequiredType(type, enclosingElement);
     }
     return type;
   }
 
   ResolutionResult visitLiteralList(LiteralList node) {
     bool isValidAsConstant = true;
     sendIsMemberAccess = false;
 
     NodeList arguments = node.typeArguments;
     DartType typeArgument;
@@ skipping 23 matching lines @@
       }
       listType = coreTypes.listType(typeArgument);
     } else {
       listType = coreTypes.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 303 matching lines @@
       reporter.reportErrorMessage(
           arguments,
           MessageKind.TYPE_VARIABLE_IN_CONSTANT);
       isValidAsConstant = false;
     }
     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 &&
               keyResult.isConstant &&
               valueResult.isConstant) {
             keyExpressions.add(keyResult.constant);
@@ skipping 273 matching lines @@
           TypeAnnotation type = declaration.type;
           if (type != null) {
             reporter.reportErrorMessage(
                 type, MessageKind.PARAMETER_WITH_TYPE_IN_CATCH);
           }
         }
       }
     }
 
     Scope blockScope = new BlockScope(scope);
-    doInCheckContext(() => visitIn(node.type, blockScope));

[sigurdm, 2015/10/22 09:18:03]

doInCheckContext seems to be unused now.

[Johnni Winther, 2015/10/22 10:31:55]

Good catch! Removed.

+    TypeResult exceptionTypeResult = visitIn(node.type, blockScope);
     visitIn(node.formals, blockScope);
     var oldInCatchBlock = inCatchBlock;
     inCatchBlock = true;
     visitIn(node.block, blockScope);
     inCatchBlock = oldInCatchBlock;
 
-    if (node.type != null && exceptionDefinition != null) {
-      DartType exceptionType = registry.getType(node.type);
-      Node exceptionVariable = exceptionDefinition.definitions.nodes.head;
-      VariableElementX exceptionElement =
-          registry.getDefinition(exceptionVariable);
-      exceptionElement.variables.type = exceptionType;
+    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);
     }
     if (stackTraceDefinition != null) {
       Node stackTraceVariable = stackTraceDefinition.definitions.nodes.head;
       VariableElementX stackTraceElement =
           registry.getDefinition(stackTraceVariable);
-      registry.registerInstantiatedClass(compiler.stackTraceClass);
-      stackTraceElement.variables.type = compiler.stackTraceClass.rawType;
+      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);
 }