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

pkg/compiler/lib/src/ssa/kernel_ast_adapter.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:js_runtime/shared/embedded_names.dart';
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
@@ skipping 406 matching lines @@
       TypeMaskFactory.inferredReturnTypeForElement(
           _backend.helpers.checkConcurrentModificationError,
           _globalInferenceResults);
 
   ir.Procedure get checkSubtype =>
       kernel.functions[_backend.helpers.checkSubtype];
 
   ir.Procedure get checkSubtypeOfRuntimeType =>
       kernel.functions[_backend.helpers.checkSubtypeOfRuntimeType];
 
-  ir.Procedure get assertHelper =>
-      kernel.functions[_backend.helpers.assertHelper];
+  ir.Procedure get throwTypeError =>
+      kernel.functions[_backend.helpers.throwTypeError];
 
   TypeMask get throwTypeErrorType =>
       TypeMaskFactory.inferredReturnTypeForElement(
           _backend.helpers.throwTypeError, _globalInferenceResults);
 
+  ir.Procedure get assertHelper =>
+      kernel.functions[_backend.helpers.assertHelper];
+
   TypeMask get assertHelperReturnType =>
       TypeMaskFactory.inferredReturnTypeForElement(
           _backend.helpers.assertHelper, _globalInferenceResults);
 
   ir.Procedure get assertTest => kernel.functions[_backend.helpers.assertTest];
 
   TypeMask get assertTestReturnType =>
       TypeMaskFactory.inferredReturnTypeForElement(
           _backend.helpers.assertTest, _globalInferenceResults);
 
@@ skipping 56 matching lines @@
         ConstantValue indexConstant = constant.fields.values.single;
         if (indexConstant is IntConstantValue) {
           return indexConstant.primitiveValue;
         }
       }
     }
     return null;
   }
 
   ResolutionDartType getDartType(ir.DartType type) {
-    return type.accept(_typeConverter);
+    return _typeConverter.convert(type);
+  }
+
+  ResolutionDartType getDartTypeInvalidNull(ir.DartType type) {

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

nit: rename, some ideas:
 - getDartTypeIfValid (I like this one best)
 - getValidDartType, or
 - getValidDartTypeOrNull

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

Done.

+    if (type is ir.InvalidType) return null;
+    return _typeConverter.convert(type);
   }
 
   List<ResolutionDartType> getDartTypes(List<ir.DartType> types) {
     return types.map(getDartType).toList();
   }
 
   ResolutionDartType getDartTypeOfListLiteral(ir.ListLiteral list) {
     ast.Node node = getNodeOrNull(list);
     if (node != null) return elements.getType(node);
     assertNodeIsSynthetic(list);
     return _compiler.commonElements.listType(getDartType(list.typeArgument));
   }
 
   ResolutionDartType getDartTypeOfMapLiteral(ir.MapLiteral literal) {
     ast.Node node = getNodeOrNull(literal);
     if (node != null) return elements.getType(node);
     assertNodeIsSynthetic(literal);
     return _compiler.commonElements
         .mapType(getDartType(literal.keyType), getDartType(literal.valueType));
   }
 
   ResolutionDartType getFunctionReturnType(ir.FunctionNode node) {
+    if (node.returnType is ir.InvalidType) return const ResolutionDynamicType();
     return getDartType(node.returnType);
   }
 
   /// Computes the function type corresponding the signature of [node].
   ResolutionFunctionType getFunctionType(ir.FunctionNode node) {
     ResolutionDartType returnType = getFunctionReturnType(node);
     List<ResolutionDartType> parameterTypes = <ResolutionDartType>[];
     List<ResolutionDartType> optionalParameterTypes = <ResolutionDartType>[];
     for (ir.VariableDeclaration variable in node.positionalParameters) {
       if (parameterTypes.length == node.requiredParameterCount) {
@@ skipping 230 matching lines @@
   JS,
   JS_BUILTIN,
   JS_EMBEDDED_GLOBAL,
   JS_INTERCEPTOR_CONSTANT,
   NONE,
 }
 
 /// Visitor that converts kernel dart types into [ResolutionDartType].
 class DartTypeConverter extends ir.DartTypeVisitor<ResolutionDartType> {
   final KernelAstAdapter astAdapter;
+  bool topLevel = true;
 
   DartTypeConverter(this.astAdapter);
 
-  ResolutionDartType visitType(ir.DartType type) => type.accept(this);
+  ResolutionDartType convert(ir.DartType type) {
+    topLevel = true;
+    return type.accept(this);
+  }
+
+  /// Visit a inner type.
+  ResolutionDartType visitType(ir.DartType type) {
+    topLevel = false;
+    return type.accept(this);
+  }
 
   List<ResolutionDartType> visitTypes(List<ir.DartType> types) {
+    topLevel = false;
     return new List.generate(
         types.length, (int index) => types[index].accept(this));
   }
 
   @override
   ResolutionDartType visitTypeParameterType(ir.TypeParameterType node) {
     if (node.parameter.parent is ir.Class) {
       ir.Class cls = node.parameter.parent;
       int index = cls.typeParameters.indexOf(node.parameter);
       ClassElement classElement = astAdapter.getElement(cls);
@@ skipping 38 matching lines @@
     return const ResolutionVoidType();
   }
 
   @override
   ResolutionDartType visitDynamicType(ir.DynamicType node) {
     return const ResolutionDynamicType();
   }
 
   @override
   ResolutionDartType visitInvalidType(ir.InvalidType node) {
-    throw new UnimplementedError("Invalid types not currently supported");
+    if (topLevel) {
+      throw new UnimplementedError(
+          "Outermost invalid types not currently supported");
+    }
+    // Nested invalid types are treated as `dynamic`.
+    return const ResolutionDynamicType();
   }
 }
 
 /// Visitor that converts string literals and concatenations of string literals
 /// into the string value.
 class Stringifier extends ir.ExpressionVisitor<String> {
   @override
   String visitStringLiteral(ir.StringLiteral node) => node.value;
 
   @override
@@ skipping 106 matching lines @@
 
   @override
   String get name => null;
 
   @override
   int get nestingLevel => 1;
 
   @override
   ast.Node get statement => null;
 }