[dart2js] Fix narrowType to handle NeverType in assert.

Change-Id: Iacd4d07b8a9bbde99e7f33d1f584d5f79d2d6e9e
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/138260
Commit-Queue: Joshua Litt <[email protected]>
Reviewed-by: Sigmund Cherem <[email protected]>

Author: joshualitt

pkg/compiler/lib/src/inferrer/type_graph_nodes.dart

@@ -2248,37 +2248,43 @@ abstract class TypeInformationVisitor<T> {
   T visitYieldTypeInformation(YieldTypeInformation info);
 }
 
+AbstractValue _intersection(AbstractValue type, AbstractValue otherType,
+    AbstractValueDomain abstractValueDomain, bool isNullable) {
+  if (isNullable) {
+    otherType = abstractValueDomain.includeNull(otherType);
+  }
+  return type == null
+      ? otherType
+      : abstractValueDomain.intersection(type, otherType);
+}
+
 AbstractValue _narrowType(
     JClosedWorld closedWorld, AbstractValue type, DartType annotation,
     {bool isNullable: true}) {
   annotation = annotation.withoutNullability;
   AbstractValueDomain abstractValueDomain = closedWorld.abstractValueDomain;
-  AbstractValue otherType;
-  if (closedWorld.dartTypes.isTopType(annotation)) {
+  // TODO(joshualitt): FutureOrType, TypeVariableType, and FunctionTypeVariable
+  // can be narrowed.
+  if (closedWorld.dartTypes.isTopType(annotation) ||
+      annotation is VoidType ||
+      annotation is NeverType ||
+      annotation is FutureOrType ||
+      annotation is TypeVariableType ||
+      annotation is FunctionTypeVariable) {
     return type;
   } else if (annotation is InterfaceType) {
     if (annotation.element == closedWorld.commonElements.objectClass) {
       return type;
     }
-    otherType = abstractValueDomain.createNonNullSubtype(annotation.element);
-  } else if (annotation is VoidType) {
-    return type;
+    return _intersection(
+        type,
+        abstractValueDomain.createNonNullSubtype(annotation.element),
+        abstractValueDomain,
+        isNullable);
   } else if (annotation is FunctionType) {
-    otherType = closedWorld.abstractValueDomain.functionType;
-  } else if (annotation is FutureOrType) {
-    // TODO(johnniwinther): Narrow FutureOr types.
-    return type;
+    return _intersection(type, closedWorld.abstractValueDomain.functionType,
+        abstractValueDomain, isNullable);
   } else {
-    assert(
-        annotation is TypeVariableType || annotation is FunctionTypeVariable);
-    // TODO(ngeoffray): Narrow to bound.
-    return type;
-  }
-  if (isNullable) {
-    otherType = abstractValueDomain.includeNull(otherType);
-  }
-  if (type == null) {
-    return otherType;
+    throw 'Unexpected annotation type $annotation';
   }
-  return abstractValueDomain.intersection(type, otherType);
 }