Support new malformed types semantics.

sdk/lib/_internal/compiler/implementation/ssa/builder.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 ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 1701 matching lines @@
       // Otherwise it is a lazy initializer which does not have parameters.
       assert(element is VariableElement);
     }
   }
 
   HInstruction buildTypeConversion(HInstruction original,
                                    DartType type,
                                    int kind) {
     if (type == null) return original;
     type = type.unalias(compiler);
-    if (type.kind == TypeKind.INTERFACE && !type.isMalformed && !type.isRaw) {
+    if (type.kind == TypeKind.INTERFACE && !type.isRaw) {
      HType subtype = new HType.subtype(type, compiler);
      HInstruction representations = buildTypeArgumentRepresentations(type);
      add(representations);
      return new HTypeConversion.withTypeRepresentation(type, kind, subtype,
           original, representations);
     } else if (type.kind == TypeKind.TYPE_VARIABLE) {
       HType subtype = original.instructionType;
       HInstruction typeVariable = addTypeVariableReference(type);
       return new HTypeConversion.withTypeRepresentation(type, kind, subtype,
           original, typeVariable);
@@ skipping 985 matching lines @@
       visitBinary(left, op, right, elements.getSelector(node), node);
     }
   }
 
   void visitIsSend(Send node) {
     visit(node.receiver);
     HInstruction expression = pop();
     bool isNot = node.isIsNotCheck;
     DartType type = elements.getType(node.typeAnnotationFromIsCheckOrCast);
     type = type.unalias(compiler);
-    if (type.isMalformed) {
-      String reasons = Types.fetchReasonsFromMalformedType(type);
+    if (type.containsAmbiguousTypes) {
+      String reasons = Types.fetchReasonsFromAmbiguousType(type);
       if (compiler.enableTypeAssertions) {
         generateMalformedSubtypeError(node, expression, type, reasons);
       } else {
-        generateRuntimeError(node, '$type is malformed: $reasons');
+        generateRuntimeError(node, '$type is ambiguous: $reasons');
       }
     } else {
       HInstruction instruction = buildIsNode(node, type, expression);
       if (isNot) {
         add(instruction);
         instruction = new HNot(instruction);
       }
       push(instruction);
     }
   }
@@ skipping 588 matching lines @@
                       element: type.element);
     }
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [argument] must not be malformed in checked mode.
    */
   HInstruction analyzeTypeArgument(DartType argument, Node currentNode) {
-    assert(invariant(currentNode,
-                     !compiler.enableTypeAssertions || !argument.isMalformed,
-                     message: '$argument is malformed in checked mode'));
-    if (argument == compiler.types.dynamicType || argument.isMalformed) {
+    if (argument.treatAsDynamic) {
       // Represent [dynamic] as [null].
       return graph.addConstantNull(compiler);
     }
 
     List<HInstruction> inputs = <HInstruction>[];
 
     String template = rti.getTypeRepresentation(argument, (variable) {
       inputs.add(addTypeVariableReference(variable));
     });
 
@@ skipping 35 matching lines @@
     pop();
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [type] must not be malformed in checked mode.
    */
   handleNewSend(NewExpression node, InterfaceType type) {
     Send send = node.send;
-    assert(invariant(send,
-                     !compiler.enableTypeAssertions || !type.isMalformed,
-                     message: '$type is malformed in checked mode'));
     bool isListConstructor = false;
     computeType(element) {
       Element originalElement = elements[send];
       if (Elements.isFixedListConstructorCall(originalElement, send, compiler)
           || Elements.isFilledListConstructorCall(
                   originalElement, send, compiler)) {
         isListConstructor = true;
         HType inferred =
             new HType.inferredForNode(currentElement, send, compiler);
         return inferred.isUnknown() ? backend.fixedArrayType : inferred;
@@ skipping 298 matching lines @@
       Constant constant = handler.compileNodeWithDefinitions(node, elements);
       stack.add(graph.addConstant(constant, compiler));
       if (isSymbolConstructor) {
         ConstructedConstant symbol = constant;
         StringConstant stringConstant = symbol.fields.single;
         String nameString = stringConstant.toDartString().slowToString();
         compiler.enqueuer.codegen.registerConstSymbol(nameString, elements);
       }
     } else {
       DartType type = elements.getType(node);
-      if (compiler.enableTypeAssertions && type.isMalformed) {
-        String reasons = Types.fetchReasonsFromMalformedType(type);
+      if (compiler.enableTypeAssertions && type.containsAmbiguousTypes) {
+        String reasons = Types.fetchReasonsFromAmbiguousType(type);
         // TODO(johnniwinther): Change to resemble type errors from bounds check
         // on type arguments.
         generateRuntimeError(node, '$type is malformed: $reasons');
       } else {
         // TODO(karlklose): move this type registration to the codegen.
         compiler.codegenWorld.instantiatedTypes.add(type);
         handleNewSend(node, type);
       }
     }
   }
@@ skipping 1112 matching lines @@
       HInvokeStatic unwrappedException = pop();
       tryInstruction.exception = exception;
       Link<Node> link = node.catchBlocks.nodes;
 
       void pushCondition(CatchBlock catchBlock) {
         if (catchBlock.onKeyword != null) {
           DartType type = elements.getType(catchBlock.type);
           if (type == null) {
             compiler.internalError('On with no type', node: catchBlock.type);
           }
-          if (type.isMalformed) {
-            // TODO(johnniwinther): Handle malformed types in [HIs] instead.
-            HInstruction condition =
-                graph.addConstantBool(true, compiler);
-            stack.add(condition);
-          } else {
-            // TODO(karlkose): support type arguments here.
-            HInstruction condition = new HIs(type,
-                                             <HInstruction>[unwrappedException],
-                                             HIs.RAW_CHECK);
-            push(condition);
-          }
+          // TODO(karlkose): support type arguments here.
+          HInstruction condition = new HIs(type,
+                                           <HInstruction>[unwrappedException],
+                                           HIs.RAW_CHECK);
+          push(condition);
         } else {
           VariableDefinitions declaration = catchBlock.formals.nodes.head;
           HInstruction condition = null;
           if (declaration.type == null) {
             condition = graph.addConstantBool(true, compiler);
             stack.add(condition);
           } else {
             // TODO(aprelev@gmail.com): Once old catch syntax is removed
             // "if" condition above and this "else" branch should be deleted as
             // type of declared variable won't matter for the catch
@@ skipping 12 matching lines @@
 
       void visitThen() {
         CatchBlock catchBlock = link.head;
         link = link.tail;
 
         if (compiler.enableTypeAssertions) {
           // In checked mode: throw a type error if the on-catch type is
           // malformed.
           if (catchBlock.onKeyword != null) {
             DartType type = elements.getType(catchBlock.type);
-            if (type != null && type.isMalformed) {
-              String reasons = Types.fetchReasonsFromMalformedType(type);
+            if (type != null && type.containsAmbiguousTypes) {
+              String reasons = Types.fetchReasonsFromAmbiguousType(type);
               generateMalformedSubtypeError(node,
                   unwrappedException, type, reasons);
               pop();
               return;
             }
           }
         }
         if (catchBlock.exception != null) {
           localsHandler.updateLocal(elements[catchBlock.exception],
                                     unwrappedException);
@@ skipping 528 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }