Follow-up to https://chromiumcodereview.appspot.com/11416144/.

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 operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(Node node);
@@ skipping 1020 matching lines @@
     breakTargetStack = breakTargetStack.tail;
     labels = labels.outer;
   }
 }
 
 class TypeResolver {
   final Compiler compiler;
 
   TypeResolver(this.compiler);
 
-  bool anyMalformedTypesInThere(Link<DartType> list) {
+  bool anyMalformedTypes(Link<DartType> list) {
     for (Link<DartType> link = list;
         !link.isEmpty;
         link = link.tail) {
       DartType dtype = link.head;
       if (dtype is MalformedType) {
         return true;
       }
     }
     return false;
   }
@@ skipping 77 matching lines @@
         ClassElement cls = element;
         cls.ensureResolved(compiler);
         Link<DartType> arguments =
             resolveTypeArguments(node, cls.typeVariables,
                                  inStaticContext, scope,
                                  onFailure, whenResolved);
         if (cls.typeVariables.isEmpty && arguments.isEmpty) {
           // Use the canonical type if it has no type parameters.
           type = cls.computeType(compiler);
         } else {
-          // In checked mode malformed-ness of the type argument bubbles up.
-          if (anyMalformedTypesInThere(arguments) &&
-              compiler.enableTypeAssertions) {
-            type = new MalformedType(
-                new MalformedTypeElement(node, element));
+          if (anyMalformedTypes(arguments)) {
+            // Build interface type(with malformed arguments in it) and
+            // map it to this constructor invocation node(that's what

[ngeoffray, 2012/11/29 09:02:26]

missing space after node.

[aam-me, 2012/11/30 06:27:47]

Done.

+            // whenResolved does), so that ssaBuilder visitNewSend

[ngeoffray, 2012/11/29 09:02:26]

you can write [SsaBuilder.visitNewSend]

[aam-me, 2012/11/30 06:27:47]

Done.

+            // can figure out which constructor to call.
+            type = new InterfaceType(cls.declaration, arguments);

[ngeoffray, 2012/11/29 09:02:26]

I wouldn't re-use the 'type' variable here, it makes it confusing. Instead, I
would just write:
whenResolved(node, new InterfaceType(cls.declaration, arguments));

[aam-me, 2012/11/30 06:27:47]

Done.

+            whenResolved(node, type);
+            // However return malformed type element so that
+            // ConstructorResolver.visitTypeAnnotation gets [:MalformedType:]

[ngeoffray, 2012/11/29 09:02:26]

[ConstructorResolver.visitTypeAnnotation]

[aam-me, 2012/11/30 06:27:47]

Done.

+            // and decorates new expression with this malformed type.

[ngeoffray, 2012/11/29 09:02:26]

What means 'decorates' here?

[aam-me, 2012/11/30 06:27:47]

I meant "maps new expression to malformed type". Fixed.

+            // The fact that new expression has malformed type is picked up
+            // by ssaBuilder visitNewExpression, but doesn't affect ssaBuilder

[ngeoffray, 2012/11/29 09:02:26]

[SsaBuilder..]

[aam-me, 2012/11/30 06:27:47]

Done.

+            // [:visitNewSend:] (important not to affect it in production mode)

[ngeoffray, 2012/11/29 09:02:26]

[SsaBuilder.visitNewSend].

+            // since it doesn't use type we create below, but follows the

[ngeoffray, 2012/11/29 09:02:26]

use the type we created below

+            // mapping we created above from Send node element

[ngeoffray, 2012/11/29 09:02:26]

what's 'from Send node element' ? Is that the element?

[aam-me, 2012/11/30 06:27:47]

"Send node" is a parameter to [SsaBuilder.visitNewSend].
"Send node element" is an element that is retrieved from [elements] collections:

  visitNewSend(Send node, InterfaceType type) {
...
  Element constructor = elements[node]; 
...
  HType elementType = computeType(constructor);
...
  }

I rewrote couple statements above and removed some unnecessary details too.
Hopefully it is more clear now.

+            // to InterfaceType.
+            type = new MalformedType(new MalformedTypeElement(node, element));
+            return type;
           } else {
             if (arguments.isEmpty) {
               // Use the canonical raw type if the class is generic.
               type = cls.rawType;
             } else {
               type = new InterfaceType(cls.declaration, arguments);
             }
           }
         }
       } else if (element.isTypedef()) {
@@ skipping 2005 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }