More functionality in kernel_impact.

pkg/compiler/lib/src/resolution/resolution.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;
 
 import 'dart:collection' show Queue;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 297 matching lines @@
       }
       if (element.isSynthesized) {
         if (element.isGenerativeConstructor) {
           ResolutionRegistry registry =
               new ResolutionRegistry(this.target, _ensureTreeElements(element));
           ConstructorElement constructor = element.asFunctionElement();
           ConstructorElement target = constructor.definingConstructor;
           // Ensure the signature of the synthesized element is
           // resolved. This is the only place where the resolver is
           // seeing this element.
-          element.computeType(resolution);
+          FunctionType type = element.computeType(resolution);
           if (!target.isMalformed) {
             registry.registerStaticUse(new StaticUse.superConstructorInvoke(
-                target, CallStructure.NO_ARGS));
+                // TODO(johnniwinther): Provide the right call structure for
+                // forwarding constructors.
+                target,
+                CallStructure.NO_ARGS));
           }
+          // TODO(johnniwinther): Remove this substitution when synthesized
+          // constructors handle type variables correctly.
+          type = type.substByContext(
+              constructor.enclosingClass.asInstanceOf(target.enclosingClass));
+          type.parameterTypes.forEach(registry.registerCheckedModeCheck);
+          type.optionalParameterTypes
+              .forEach(registry.registerCheckedModeCheck);
+          type.namedParameterTypes.forEach(registry.registerCheckedModeCheck);
           return registry.impactBuilder;
         } else {
           assert(element.isDeferredLoaderGetter || element.isMalformed);
           _ensureTreeElements(element);
           return const ResolutionImpact();
         }
       } else {
         element.parseNode(resolution.parsingContext);
         element.computeType(resolution);
         FunctionElementX implementation = element;
@@ skipping 42 matching lines @@
                 // `Foo<Unresolved>`.
                 element.variables.type.toString() == type.toString(),
             message: "Unexpected type computed for $element. "
                 "Was ${element.variables.type}, computed $type."));
         element.variables.type = type;
       } else if (element.variables.type == null) {
         // Only assign the dynamic type if the element has no known type. This
         // happens for enum fields where the type is known but is not in the
         // synthesized AST.
         element.variables.type = const DynamicType();
+      } else {
+        registry.registerCheckedModeCheck(element.variables.type);
       }
 
       Expression initializer = element.initializer;
       Modifiers modifiers = element.modifiers;
       if (initializer != null) {
         // TODO(johnniwinther): Avoid analyzing initializers if
         // [Compiler.analyzeSignaturesOnly] is set.
         ResolutionResult result = visitor.visit(initializer);
         if (result.isConstant) {
           element.constant = result.constant;
@@ skipping 729 matching lines @@
   TreeElements get treeElements {
     assert(invariant(this, _treeElements != null,
         message: "TreeElements have not been computed for $this."));
     return _treeElements;
   }
 
   void reuseElement() {
     _treeElements = null;
   }
 }