Improve type of typed-array load

- Typed array elements are never null, but type inference sometimes
  thinks they are.

- Annotated isNan and isFinite as pure.

Change-Id: I5fffd237374444db27665009cf550b26563bcf55
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/98046
Reviewed-by: Sigmund Cherem <sigmund@google.com>
Commit-Queue: Stephen Adams <sra@google.com>

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

@@ -197,24 +197,28 @@ class IndexSpecializer extends InvokeDynamicSpecializer {
       JCommonElements commonElements,
       JClosedWorld closedWorld,
       OptimizationTestLog log) {
+    var abstractValueDomain = closedWorld.abstractValueDomain;
     if (instruction.inputs[1]
-        .isIndexablePrimitive(closedWorld.abstractValueDomain)
+        .isIndexablePrimitive(abstractValueDomain)
         .isPotentiallyFalse) {
       return null;
     }
     if (instruction.inputs[2]
-            .isInteger(closedWorld.abstractValueDomain)
+            .isInteger(abstractValueDomain)
             .isPotentiallyFalse &&
         options.parameterCheckPolicy.isEmitted) {
       // We want the right checked mode error.
       return null;
     }
     AbstractValue receiverType =
         instruction.getDartReceiver(closedWorld).instructionType;
-    AbstractValue type = AbstractValueFactory.inferredTypeForSelector(
+    AbstractValue elementType = AbstractValueFactory.inferredTypeForSelector(
         instruction.selector, receiverType, results);
+    if (abstractValueDomain.isTypedArray(receiverType).isDefinitelyTrue) {
+      elementType = abstractValueDomain.excludeNull(elementType);
+    }
     HIndex converted = new HIndex(instruction.inputs[1], instruction.inputs[2],
-        instruction.selector, type);
+        instruction.selector, elementType);
     log?.registerIndex(instruction, converted);
     return converted;
   }

sdk/lib/_internal/js_runtime/lib/js_number.dart

@@ -40,13 +40,19 @@ class JSNumber extends Interceptor implements double {
 
   bool get isNegative => (this == 0) ? (1 / this) < 0 : this < 0;
 
-  bool get isNaN => JS('bool', r'isNaN(#)', this);
+  bool get isNaN => JS(
+      'returns:bool;effects:none;depends:none;throws:never;gvn:true',
+      r'isNaN(#)',
+      this);
 
   bool get isInfinite {
     return JS('bool', r'# == (1/0)', this) || JS('bool', r'# == (-1/0)', this);
   }
 
-  bool get isFinite => JS('bool', r'isFinite(#)', this);
+  bool get isFinite => JS(
+      'returns:bool;effects:none;depends:none;throws:never;gvn:true',
+      r'isFinite(#)',
+      this);
 
   JSNumber remainder(num b) {
     if (b is! num) throw argumentErrorValue(b);