Treat ambiguous types as malformed.

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 2752 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.containsAmbiguousTypes) {
-      String reasons = Types.fetchReasonsFromAmbiguousType(type);
-      if (compiler.enableTypeAssertions) {
-        generateMalformedSubtypeError(node, expression, type, reasons);
-      } else {
-        generateRuntimeError(node, '$type is ambiguous: $reasons');
-      }
-    } else {
-      HInstruction instruction = buildIsNode(node, type, expression);
-      if (isNot) {
-        add(instruction);
-        instruction = new HNot(instruction);
-      }
-      push(instruction);
+    HInstruction instruction = buildIsNode(node, type, expression);
+    if (isNot) {
+      add(instruction);
+      instruction = new HNot(instruction);
     }
+    push(instruction);
   }
 
   HLiteralList buildTypeVariableList(ClassElement contextClass) {
     List<HInstruction> inputs = <HInstruction>[];
     for (Link<DartType> link = contextClass.typeVariables;
         !link.isEmpty;
         link = link.tail) {
       inputs.add(addTypeVariableReference(link.head));
     }
     return buildLiteralList(inputs);
@@ skipping 604 matching lines @@
       return readTypeVariable(member.getEnclosingClass(),
                               type.element);
     } else {
       // TODO(ngeoffray): Match the VM behavior and throw an
       // exception at runtime.
       compiler.cancel('Unimplemented unresolved type variable',
                       element: type.element);
     }
   }
 
-  /**
-   * Documentation wanted -- johnniwinther
-   *
-   * Invariant: [argument] must not be malformed in checked mode.
-   */
   HInstruction analyzeTypeArgument(DartType argument) {
     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 30 matching lines @@
     // Set the runtime type information on the object.
     Element typeInfoSetterElement = backend.getSetRuntimeTypeInfo();
     pushInvokeStatic(
         null,
         typeInfoSetterElement,
         <HInstruction>[newObject, typeInfo],
         HType.UNKNOWN);
     pop();
   }
 
-  /**
-   * Documentation wanted -- johnniwinther
-   *
-   * Invariant: [type] must not be malformed in checked mode.
-   */
   handleNewSend(NewExpression node, InterfaceType type) {
     Send send = node.send;
     bool isListConstructor = false;
     computeType(element) {
       Element originalElement = elements[send];
       if (Elements.isFixedListConstructorCall(originalElement, send, compiler)
           || Elements.isFilledListConstructorCall(
                   originalElement, send, compiler)) {
         isListConstructor = true;
         HType inferred =
@@ skipping 256 matching lines @@
     FunctionSignature signature = function.computeSignature(compiler);
     signature.forEachParameter((Element parameter) {
       existingArguments.add(parameter.name.slowToString());
     });
     generateThrowNoSuchMethod(diagnosticNode,
                               function.name.slowToString(),
                               argumentNodes: argumentNodes,
                               existingArguments: existingArguments);
   }
 
-  void generateMalformedSubtypeError(Node node, HInstruction value,
-                                     DartType type, String reasons) {
-    HInstruction typeString = addConstantString(node, type.toString());
-    HInstruction reasonsString = addConstantString(node, reasons);
-    Element helper = backend.getThrowMalformedSubtypeError();
-    pushInvokeStatic(node, helper, [value, typeString, reasonsString]);
-  }
-
   visitNewExpression(NewExpression node) {
     Element element = elements[node.send];
     final bool isSymbolConstructor = element == compiler.symbolConstructor;
     if (!Elements.isErroneousElement(element)) {
       FunctionElement function = element;
       element = function.redirectionTarget;
     }
     if (Elements.isErroneousElement(element)) {
       ErroneousElement error = element;
       if (error.messageKind == MessageKind.CANNOT_FIND_CONSTRUCTOR.error) {
         generateThrowNoSuchMethod(node.send,
                                   getTargetName(error, 'constructor'),
                                   argumentNodes: node.send.arguments);
       } else {
         Message message = error.messageKind.message(error.messageArguments);
         generateRuntimeError(node.send, message.toString());
       }
     } else if (node.isConst()) {
       ConstantHandler handler = compiler.constantHandler;
       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.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);
-      }
+      // TODO(karlklose): move this type registration to the codegen.
+      compiler.codegenWorld.instantiatedTypes.add(type);
+      handleNewSend(node, type);
     }
   }
 
   void pushInvokeDynamic(Node node,
                          Selector selector,
                          List<HInstruction> arguments,
                          {Node location}) {
     if (location == null) location = node;
 
     // We prefer to not inline certain operations on indexables,
@@ skipping 1140 matching lines @@
             condition = new HIs(type, <HInstruction>[unwrappedException],
                                 HIs.RAW_CHECK);
             push(condition);
           }
         }
       }
 
       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.containsAmbiguousTypes) {
-              String reasons = Types.fetchReasonsFromAmbiguousType(type);
-              generateMalformedSubtypeError(node,
-                  unwrappedException, type, reasons);
-              pop();
-              return;
-            }
-          }
-        }
         if (catchBlock.exception != null) {
           localsHandler.updateLocal(elements[catchBlock.exception],
                                     unwrappedException);
         }
         Node trace = catchBlock.trace;
         if (trace != null) {
           pushInvokeStatic(trace, backend.getTraceFromException(), [exception]);
           HInstruction traceInstruction = pop();
           localsHandler.updateLocal(elements[trace], traceInstruction);
         }
@@ skipping 525 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;
   }
 }