dart2js-kernel: special-case InvalidType in 'is' and 'as'

pkg/compiler/lib/src/ssa/builder_kernel.dart

 // Copyright (c) 2016, 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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart';
@@ skipping 180 matching lines @@
     assert(graph.isValid());
     return graph;
   }
 
   void buildField(ir.Field field) {
     openFunction();
     if (field.initializer != null) {
       field.initializer.accept(this);
       HInstruction fieldValue = pop();
       HInstruction checkInstruction = typeBuilder.potentiallyCheckOrTrustType(
-          fieldValue, astAdapter.getDartType(field.type));
+          fieldValue, astAdapter.getDartTypeInvalidNull(field.type));
       stack.add(checkInstruction);
     } else {
       stack.add(graph.addConstantNull(closedWorld));
     }
     HInstruction value = pop();
     closeAndGotoExit(new HReturn(value, null));
     closeFunction();
   }
 
   /// Pops the most recent instruction from the stack and 'boolifies' it.
@@ skipping 743 matching lines @@
     handleIf(
         visitCondition: () => ifStatement.condition.accept(this),
         visitThen: () => ifStatement.then.accept(this),
         visitElse: () => ifStatement.otherwise?.accept(this));
   }
 
   @override
   void visitAsExpression(ir.AsExpression asExpression) {
     asExpression.operand.accept(this);
     HInstruction expressionInstruction = pop();
+
+    if (asExpression.type is ir.InvalidType) {
+      generateTypeError(asExpression, 'invalid type');
+      stack.add(expressionInstruction);
+      return;
+    }
+
     ResolutionDartType type = astAdapter.getDartType(asExpression.type);
     if (type.isMalformed) {
       if (type is MalformedType) {
         ErroneousElement element = type.element;
         generateTypeError(asExpression, element.message);
       } else {
         assert(type is MethodTypeVariableType);
         stack.add(expressionInstruction);
       }
     } else {
       HInstruction converted = typeBuilder.buildTypeConversion(
           expressionInstruction,
           localsHandler.substInContext(type),
           HTypeConversion.CAST_TYPE_CHECK);
       if (converted != expressionInstruction) {
         add(converted);
       }
       stack.add(converted);
     }
   }
 
-  void generateError(ir.Node node, String message, TypeMask typeMask) {
+  void generateError(
+      ir.Node node, ir.Procedure procedure, String message, TypeMask typeMask) {
     HInstruction errorMessage =
         graph.addConstantString(new DartString.literal(message), closedWorld);
-    _pushStaticInvocation(node, [errorMessage], typeMask);
+    // TODO(sra): Assocate source info from [node].
+    _pushStaticInvocation(procedure, [errorMessage], typeMask);
   }
 
   void generateTypeError(ir.Node node, String message) {
-    generateError(node, message, astAdapter.throwTypeErrorType);
+    generateError(node, astAdapter.throwTypeError, message,
+        astAdapter.throwTypeErrorType);
   }
 
   @override
   void visitAssertStatement(ir.AssertStatement assertStatement) {
     if (!compiler.options.enableUserAssertions) return;
     if (assertStatement.message == null) {
       assertStatement.condition.accept(this);
       _pushStaticInvocation(astAdapter.assertHelper, <HInstruction>[pop()],
           astAdapter.assertHelperReturnType);
       pop();
@@ skipping 309 matching lines @@
 
     var staticTarget = staticSet.target;
     if (staticTarget is ir.Procedure) {
       // Invoke the setter
       _pushStaticInvocation(staticTarget, <HInstruction>[value],
           astAdapter.returnTypeOf(staticTarget));
       pop();
     } else {
       add(new HStaticStore(
           astAdapter.getMember(staticTarget),
-          typeBuilder.potentiallyCheckOrTrustType(
-              value, astAdapter.getDartType(staticTarget.setterType))));
+          typeBuilder.potentiallyCheckOrTrustType(value,
+              astAdapter.getDartTypeInvalidNull(staticTarget.setterType))));
     }
     stack.add(value);
   }
 
   @override
   void visitPropertyGet(ir.PropertyGet propertyGet) {
     propertyGet.receiver.accept(this);
     HInstruction receiver = pop();
 
     _pushDynamicInvocation(propertyGet, astAdapter.typeOfGet(propertyGet),
@@ skipping 58 matching lines @@
 
     // Give the value a name if it doesn't have one already.
     if (value.sourceElement == null) {
       value.sourceElement = local;
     }
 
     stack.add(value);
     localsHandler.updateLocal(
         local,
         typeBuilder.potentiallyCheckOrTrustType(
-            value, astAdapter.getDartType(variable.type)));
+            value, astAdapter.getDartTypeInvalidNull(variable.type)));
   }
 
   @override
   void visitLet(ir.Let let) {
     ir.VariableDeclaration variable = let.variable;
     variable.initializer.accept(this);
     HInstruction initializedValue = pop();
     // TODO(sra): Apply inferred type information.
     letBindings[variable] = initializedValue;
     let.body.accept(this);
@@ skipping 713 matching lines @@
         _visitArgumentsForStaticTarget(target.function, invocation.arguments);
     TypeMask typeMask = new TypeMask.nonNullExact(
         astAdapter.getClass(target.enclosingClass), closedWorld);
     _pushStaticInvocation(target, arguments, typeMask);
   }
 
   @override
   void visitIsExpression(ir.IsExpression isExpression) {
     isExpression.operand.accept(this);
     HInstruction expression = pop();
-    push(buildIsNode(isExpression, isExpression.type, expression));
+    pushIsTest(isExpression, isExpression.type, expression);
   }
 
-  HInstruction buildIsNode(
-      ir.Node node, ir.DartType type, HInstruction expression) {
+  void pushIsTest(ir.Node node, ir.DartType type, HInstruction expression) {
     // Note: The call to "unalias" this type like in the original SSA builder is
     // unnecessary in kernel because Kernel has no notion of typedef.
     // TODO(efortuna): Add test for this.
+
+    if (type is ir.InvalidType) {
+      // TODO(sra): Make InvalidType carry a message.
+      generateTypeError(node, 'invalid type');
+      pop();
+      stack.add(graph.addConstantBool(true, closedWorld));
+      return;
+    }
+
     ResolutionDartType typeValue =
         localsHandler.substInContext(astAdapter.getDartType(type));
-    if (type is ir.InvalidType) {
-      generateTypeError(node, (typeValue.element as ErroneousElement).message);
-      return new HIs.compound(
-          typeValue, expression, pop(), commonMasks.boolType);
-    }
-
     if (type is ir.FunctionType) {
       List arguments = [buildFunctionType(typeValue), expression];
       _pushDynamicInvocation(node, null, arguments,
           selector: new Selector.call(
               new PrivateName('_isTest', backend.helpers.jsHelperLibrary),
               CallStructure.ONE_ARG));
-      return new HIs.compound(
-          typeValue, expression, pop(), commonMasks.boolType);
+      push(
+          new HIs.compound(typeValue, expression, pop(), commonMasks.boolType));
+      return;
     }
 
     if (type is ir.TypeParameterType) {
       HInstruction runtimeType =
           typeBuilder.addTypeVariableReference(typeValue, sourceElement);
       _pushStaticInvocation(astAdapter.checkSubtypeOfRuntimeType,
           <HInstruction>[expression, runtimeType], commonMasks.boolType);
-      return new HIs.variable(
-          typeValue, expression, pop(), commonMasks.boolType);
+      push(
+          new HIs.variable(typeValue, expression, pop(), commonMasks.boolType));
+      return;
     }
 
     if (_isInterfaceWithNoDynamicTypes(type)) {
       HInstruction representations = typeBuilder
           .buildTypeArgumentRepresentations(typeValue, sourceElement);
       add(representations);
       ClassElement element = typeValue.element;
       js.Name operator = backend.namer.operatorIs(element);
       HInstruction isFieldName =
           graph.addConstantStringFromName(operator, closedWorld);
       HInstruction asFieldName = closedWorld.hasAnyStrictSubtype(element)
           ? graph.addConstantStringFromName(
               backend.namer.substitutionName(element), closedWorld)
           : graph.addConstantNull(closedWorld);
       List<HInstruction> inputs = <HInstruction>[
         expression,
         isFieldName,
         representations,
         asFieldName
       ];
       _pushStaticInvocation(
           astAdapter.checkSubtype, inputs, commonMasks.boolType);
-      return new HIs.compound(
-          typeValue, expression, pop(), commonMasks.boolType);
+      push(
+          new HIs.compound(typeValue, expression, pop(), commonMasks.boolType));
+      return;
     }
 
     if (backend.hasDirectCheckFor(typeValue)) {
-      return new HIs.direct(typeValue, expression, commonMasks.boolType);
+      push(new HIs.direct(typeValue, expression, commonMasks.boolType));
+      return;
     }
     // The interceptor is not always needed.  It is removed by optimization
     // when the receiver type or tested type permit.
-    return new HIs.raw(typeValue, expression, _interceptorFor(expression),
-        commonMasks.boolType);
+    push(new HIs.raw(typeValue, expression, _interceptorFor(expression),
+        commonMasks.boolType));
+    return;
   }
 
   bool _isInterfaceWithNoDynamicTypes(ir.DartType type) {
     bool isMethodTypeVariableType(ir.DartType typeArgType) {
       return (typeArgType is ir.TypeParameterType &&
           typeArgType.parameter.parent is ir.FunctionNode);
     }
 
     return type is ir.InterfaceType &&
         (type as ir.InterfaceType).typeArguments.any(
@@ skipping 226 matching lines @@
     kernelBuilder._pushStaticInvocation(
         kernelBuilder.astAdapter.exceptionUnwrapper,
         [exception],
         kernelBuilder.astAdapter.exceptionUnwrapperType);
     HInvokeStatic unwrappedException = kernelBuilder.pop();
     tryInstruction.exception = exception;
     int catchesIndex = 0;
 
     void pushCondition(ir.Catch catchBlock) {
       if (catchBlock.guard is! ir.DynamicType) {
-        HInstruction condition = kernelBuilder.buildIsNode(
+        kernelBuilder.pushIsTest(
             catchBlock.exception, catchBlock.guard, unwrappedException);
-        kernelBuilder.push(condition);
       } else {
         kernelBuilder.stack.add(kernelBuilder.graph

[Siggi Cherem (dart-lang), 2017/01/13 16:38:22]

actually - should we handle `guard is DynamicType` directly in pushIsTest?
(practically move the if-else there)

[sra1, 2017/01/13 18:53:11]

Done.

             .addConstantBool(true, kernelBuilder.closedWorld));
       }
     }
 
     void visitThen() {
       ir.Catch catchBlock = tryCatch.catches[catchesIndex];
       catchesIndex++;
       if (catchBlock.exception != null) {
         LocalVariableElement exceptionVariable =
             kernelBuilder.astAdapter.getElement(catchBlock.exception);
@@ skipping 59 matching lines @@
     kernelBuilder.open(exitBlock);
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
   }
 }