improve DDC's type checks

pkg/dev_compiler/lib/src/compiler/code_generator.dart

 // Copyright (c) 2015, 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 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 122 matching lines @@
   final InterfaceType _asyncStreamIterator;
 
   /// The dart:core `identical` element.
   final FunctionElement _coreIdentical;
 
   /// The dart:_interceptors JSArray element.
   final ClassElement _jsArray;
 
   final ClassElement boolClass;
   final ClassElement intClass;
+  final ClassElement doubleClass;
   final ClassElement interceptorClass;
   final ClassElement nullClass;
   final ClassElement numClass;
   final ClassElement objectClass;
   final ClassElement stringClass;
   final ClassElement functionClass;
   final ClassElement privateSymbolClass;
 
   ConstFieldVisitor _constants;
 
@@ skipping 50 matching lines @@
         _asyncStreamIterator =
             _getLibrary(c, 'dart:async').getType('StreamIterator').type,
         _coreIdentical =
             _getLibrary(c, 'dart:core').publicNamespace.get('identical'),
         _jsArray = _getLibrary(c, 'dart:_interceptors').getType('JSArray'),
         interceptorClass =
             _getLibrary(c, 'dart:_interceptors').getType('Interceptor'),
         dartCoreLibrary = _getLibrary(c, 'dart:core'),
         boolClass = _getLibrary(c, 'dart:core').getType('bool'),
         intClass = _getLibrary(c, 'dart:core').getType('int'),
+        doubleClass = _getLibrary(c, 'dart:core').getType('double'),
         numClass = _getLibrary(c, 'dart:core').getType('num'),
         nullClass = _getLibrary(c, 'dart:core').getType('Null'),
         objectClass = _getLibrary(c, 'dart:core').getType('Object'),
         stringClass = _getLibrary(c, 'dart:core').getType('String'),
         functionClass = _getLibrary(c, 'dart:core').getType('Function'),
         privateSymbolClass =
             _getLibrary(c, 'dart:_internal').getType('PrivateSymbol'),
         dartJSLibrary = _getLibrary(c, 'dart:js') {
     typeRep = new JSTypeRep(rules, types);
   }
@@ skipping 610 matching lines @@
     if (isGeneric) {
       if (isMixinAlias) {
         block.add(js.statement('const # = #;', [className, classExpr]));
       } else {
         block.add(new JS.ClassDeclaration(classExpr));
       }
     } else {
       block.add(js.statement('# = #;', [className, classExpr]));
     }
 
+    JS.Statement finishGenericTypeTest;
+
     if (!isMixinAlias) {
       block.addAll(_defineConstructors(classElem, className, [], []));
+      finishGenericTypeTest = _emitClassTypeTests(classElem, className, block);
     }
 
     if (classElem.interfaces.isNotEmpty) {
       block.add(js.statement('#[#.implements] = () => #;', [
         className,
         _runtimeModule,
         new JS.ArrayInitializer(classElem.interfaces.map(_emitType).toList())
       ]));
     }
 
     if (isGeneric) {
-      return _defineClassTypeArguments(
-          classElem, typeFormals, _statement(block));
+      var classDef =
+          _defineClassTypeArguments(classElem, typeFormals, _statement(block));
+      if (finishGenericTypeTest == null) return classDef;
+      block = [classDef, finishGenericTypeTest];
     }
     return _statement(block);
   }
 
   JS.Statement _emitJSType(Element e) {
     var jsTypeName = getAnnotationName(e, isJSAnnotation);
     if (jsTypeName == null || jsTypeName == e.name) return null;
 
     // We export the JS type as if it was a Dart type. For example this allows
     // `dom.InputElement` to actually be HTMLInputElement.
@@ skipping 57 matching lines @@
 
     // Emit the class, e.g. `core.Object = class Object { ... }`
     _defineClass(classElem, className, classExpr, body);
     body.addAll(jsCtors);
 
     // Emit things that come after the ES6 `class ... { ... }`.
     var jsPeerNames = _getJSPeerNames(classElem);
     JS.Statement deferredBaseClass =
         _setBaseClass(classElem, className, jsPeerNames, body);
 
-    _emitClassTypeTests(classElem, className, body);
+    var finishGenericTypeTest = _emitClassTypeTests(classElem, className, body);
 
     _emitVirtualFieldSymbols(classElem, body);
     _emitClassSignature(methods, allFields, classElem, ctors, className, body);
     _defineExtensionMembers(className, body);
     _emitClassMetadata(node.metadata, className, body);
 
     JS.Statement classDef = _statement(body);
 
     var typeFormals = classElem.typeParameters;
     if (typeFormals.isNotEmpty) {
       classDef = _defineClassTypeArguments(
           classElem, typeFormals, classDef, className, deferredBaseClass);
     }
 
     body = <JS.Statement>[classDef];
     _emitStaticFields(staticFields, classElem, body);
+    if (finishGenericTypeTest != null) body.add(finishGenericTypeTest);
     for (var peer in jsPeerNames) {
       _registerExtensionType(classElem, peer, body);
     }
 
     _classProperties = savedClassProperties;
     return _statement(body);
   }
 
-  void _emitClassTypeTests(ClassElement classElem, JS.Expression className,
-      List<JS.Statement> body) {
-    if (classElem == objectClass) {
-      // We rely on ES6 static inheritance.  All types that are represented by
-      // class constructor functions will see these definitions, with [this]
-      // being bound to the class constructor.
-
-      // The 'instanceof' checks don't work for primitive types (which have fast
-      // definitions below) and don't work for native types. In those cases we
-      // fall through to the general purpose checking code.
-      body.add(js.statement(
-          '#.is = function is_Object(o) {'
-          '  if (o instanceof this) return true;'
-          '  return #.is(o, this);'
-          '}',
-          [className, _runtimeModule]));
-      body.add(js.statement(
-          '#.as = function as_Object(o) {'
-          '  if (o == null || o instanceof this) return o;'
-          '  return #.as(o, this);'
-          '}',
-          [className, _runtimeModule]));
-      body.add(js.statement(
-          '#._check = function check_Object(o) {'
-          '  if (o == null || o instanceof this) return o;'
-          '  return #.check(o, this);'
-          '}',
-          [className, _runtimeModule]));
-      return;
-    }
-    if (classElem == stringClass) {
-      body.add(js.statement(
-          '#.is = function is_String(o) { return typeof o == "string"; }',
-          className));
-      body.add(js.statement(
-          '#.as = function as_String(o) {'
-          '  if (typeof o == "string" || o == null) return o;'
-          '  return #.as(o, #);'
-          '}',
-          [className, _runtimeModule, className]));
-      body.add(js.statement(
-          '#._check = function check_String(o) {'
-          '  if (typeof o == "string" || o == null) return o;'
-          '  return #.check(o, #);'
-          '}',
-          [className, _runtimeModule, className]));
-      return;
-    }
-    if (classElem == functionClass) {
-      body.add(js.statement(
-          '#.is = function is_Function(o) { return typeof o == "function"; }',
-          className));
-      body.add(js.statement(
-          '#.as = function as_Function(o) {'
-          '  if (typeof o == "function" || o == null) return o;'
-          '  return #.as(o, #);'
-          '}',
-          [className, _runtimeModule, className]));
-      body.add(js.statement(
-          '#._check = function check_String(o) {'
-          '  if (typeof o == "function" || o == null) return o;'
-          '  return #.check(o, #);'
-          '}',
-          [className, _runtimeModule, className]));
-      return;
-    }
-
-    if (classElem == intClass) {
-      body.add(js.statement(
-          '#.is = function is_int(o) {'
-          '  return typeof o == "number" && Math.floor(o) == o;'
-          '}',
-          className));
-      body.add(js.statement(
-          '#.as = function as_int(o) {'
-          '  if ((typeof o == "number" && Math.floor(o) == o) || o == null)'
-          '    return o;'
-          '  return #.as(o, #);'
-          '}',
-          [className, _runtimeModule, className]));
-      body.add(js.statement(
-          '#._check = function check_int(o) {'
-          '  if ((typeof o == "number" && Math.floor(o) == o) || o == null)'
-          '    return o;'
-          '  return #.check(o, #);'
-          '}',
-          [className, _runtimeModule, className]));
-      return;
-    }
-    if (classElem == nullClass) {
-      body.add(js.statement(
-          '#.is = function is_Null(o) { return o == null; }', className));
-      body.add(js.statement(
-          '#.as = function as_Null(o) {'
-          '  if (o == null) return o;'
-          '  return #.as(o, #);'
-          '}',
-          [className, _runtimeModule, className]));
-      body.add(js.statement(
-          '#._check = function check_Null(o) {'
-          '  if (o == null) return o;'
-          '  return #.check(o, #);'
-          '}',
-          [className, _runtimeModule, className]));
-      return;
-    }
-    if (classElem == numClass) {
-      body.add(js.statement(
-          '#.is = function is_num(o) { return typeof o == "number"; }',
-          className));
-      body.add(js.statement(
-          '#.as = function as_num(o) {'
-          '  if (typeof o == "number" || o == null) return o;'
-          '  return #.as(o, #);'
-          '}',
-          [className, _runtimeModule, className]));
-      body.add(js.statement(
-          '#._check = function check_num(o) {'
-          '  if (typeof o == "number" || o == null) return o;'
-          '  return #.check(o, #);'
-          '}',
-          [className, _runtimeModule, className]));
-      return;
-    }
-    if (classElem == boolClass) {
-      body.add(js.statement(
-          '#.is = function is_bool(o) { return o === true || o === false; }',
-          className));
-      body.add(js.statement(
-          '#.as = function as_bool(o) {'
-          '  if (o === true || o === false || o == null) return o;'
-          '  return #.as(o, #);'
-          '}',
-          [className, _runtimeModule, className]));
-      body.add(js.statement(
-          '#._check = function check_bool(o) {'
-          '  if (o === true || o === false || o == null) return o;'
-          '  return #.check(o, #);'
-          '}',
-          [className, _runtimeModule, className]));
-      return;
-    }
-    // TODO(sra): Add special cases for hot tests like `x is html.Element`.
-
-    // `instanceof` check is futile for classes that are Interceptor classes.
-    ClassElement parent = classElem;
-    while (parent != objectClass) {
-      if (parent == interceptorClass) {
-        if (classElem == interceptorClass) {
-          // Place non-instanceof version of checks on Interceptor. All
-          // interceptor classes will inherit the methods via ES6 class static
-          // inheritance.
-          body.add(_callHelperStatement('addTypeTests(#);', className));
-
-          // TODO(sra): We could place on the extension type a pointer to the
-          // peer constructor and use that for the `instanceof` check, e.g.
-          //
-          //    if (o instanceof this[_peerConstructor]) return o;
-          //
+  JS.Statement _emitClassTypeTests(ClassElement classElem,
+      JS.Expression className, List<JS.Statement> body) {
+    JS.Expression getInterfaceSymbol(ClassElement c) {
+      var library = c.library;
+      if (library.isDartCore || library.isDartAsync) {
+        switch (c.name) {
+          case 'List':
+          case 'Map':
+          case 'Iterable':
+          case 'Future':
+          case 'Stream':
+          case 'StreamSubscription':
+            return _callHelper('is' + c.name);
         }
-        return;
-      }
-      parent = parent.type.superclass.element;
-    }
-
-    // Choose between 'simple' checks, which are often accelerated by
-    // `instanceof`, and other checks, which are slowed down by taking time to
-    // do an `instanceof` check that is futile or likely futile.
-    //
-    // The `instanceof` check is futile for (1) a class that is only used as a
-    // mixin, or (2) is only used as an interface in an `implements` clause, and
-    // is likely futile (3) if the class has type parameters, since `Foo` aka
-    // `Foo<dynamic>` is not a superclass of `Foo<int>`. The first two are
-    // whole-program properites, but we can check for the last case.
-
-    // Since ES6 classes have inheritance of static properties, we need only
-    // install checks that differ from the parent.
-
-    bool isSimple(ClassElement classElement) {
-      if (classElement.typeParameters.isNotEmpty) return false;
-      return true;
-    }
-
-    assert(classElem != objectClass);
-    bool thisIsSimple = isSimple(classElem);
-    bool superIsSimple = isSimple(classElem.type.superclass.element);
-
-    if (thisIsSimple == superIsSimple) return;
-
-    if (thisIsSimple) {
-      body.add(_callHelperStatement('addSimpleTypeTests(#);', className));
-    } else {
-      body.add(_callHelperStatement('addTypeTests(#);', className));
-    }
+      }
+      return null;
+    }
+
+    void markSubtypeOf(JS.Expression testSymbol) {
+      body.add(js.statement('#.prototype[#] = true', [className, testSymbol]));
+    }
+
+    for (var iface in classElem.interfaces) {
+      var prop = getInterfaceSymbol(iface.element);
+      if (prop != null) markSubtypeOf(prop);
+    }
+
+    if (classElem.library.isDartCore) {
+      if (classElem == objectClass) {

[Leaf, 2017/08/24 17:19:39]

Is there a reason we attach these here instead of writing them in core_patch? 
Not that it really matters, just curious.

[Jennifer Messerly, 2017/08/24 18:26:37]

Yeah I'm not sure why the existing code does that. We could move these onto
their respective classes as static methods if we want to.

+        // Everything is an Object.
+        body.add(js.statement(
+            '#.is = function is_Object(o) { return true; }', [className]));
+        body.add(js.statement(
+            '#.as = function as_Object(o) { return o; }', [className]));
+        body.add(js.statement(
+            '#._check = function check_Object(o) { return o; }', [className]));
+        return null;
+      }
+      if (classElem == stringClass) {
+        body.add(js.statement(
+            '#.is = function is_String(o) { return typeof o == "string"; }',
+            className));
+        body.add(js.statement(
+            '#.as = function as_String(o) {'
+            '  if (typeof o == "string" || o == null) return o;'
+            '  return #.as(o, #, false);'
+            '}',
+            [className, _runtimeModule, className]));
+        body.add(js.statement(
+            '#._check = function check_String(o) {'
+            '  if (typeof o == "string" || o == null) return o;'
+            '  return #.as(o, #, true);'
+            '}',
+            [className, _runtimeModule, className]));
+        return null;
+      }
+      if (classElem == functionClass) {
+        body.add(js.statement(
+            '#.is = function is_Function(o) { return typeof o == "function"; }',

[Leaf, 2017/08/24 17:19:39]

Does this handle call methods? 

[Jennifer Messerly, 2017/08/24 18:26:37]

yup. Callable classes are reified as JS functions (so we can call them). so
typeof == "function" in the JS runtime, even tho the function object's __proto__
is not Function.prototype. 

+            className));
+        body.add(js.statement(
+            '#.as = function as_Function(o) {'
+            '  if (typeof o == "function" || o == null) return o;'
+            '  return #.as(o, #, false);'
+            '}',
+            [className, _runtimeModule, className]));
+        body.add(js.statement(
+            '#._check = function check_String(o) {'
+            '  if (typeof o == "function" || o == null) return o;'
+            '  return #.as(o, #, true);'
+            '}',
+            [className, _runtimeModule, className]));
+        return null;
+      }
+      if (classElem == intClass) {
+        body.add(js.statement(
+            '#.is = function is_int(o) {'
+            '  return typeof o == "number" && Math.floor(o) == o;'
+            '}',
+            className));
+        body.add(js.statement(
+            '#.as = function as_int(o) {'
+            '  if ((typeof o == "number" && Math.floor(o) == o) || o == null)'
+            '    return o;'
+            '  return #.as(o, #, false);'
+            '}',
+            [className, _runtimeModule, className]));
+        body.add(js.statement(
+            '#._check = function check_int(o) {'
+            '  if ((typeof o == "number" && Math.floor(o) == o) || o == null)'
+            '    return o;'
+            '  return #.as(o, #, true);'
+            '}',
+            [className, _runtimeModule, className]));
+        return null;
+      }
+      if (classElem == nullClass) {
+        body.add(js.statement(
+            '#.is = function is_Null(o) { return o == null; }', className));
+        body.add(js.statement(
+            '#.as = function as_Null(o) {'
+            '  if (o == null) return o;'
+            '  return #.as(o, #, false);'
+            '}',
+            [className, _runtimeModule, className]));
+        body.add(js.statement(
+            '#._check = function check_Null(o) {'
+            '  if (o == null) return o;'
+            '  return #.as(o, #, true);'
+            '}',
+            [className, _runtimeModule, className]));
+        return null;
+      }
+      if (classElem == numClass || classElem == doubleClass) {
+        body.add(js.statement(
+            '#.is = function is_num(o) { return typeof o == "number"; }',
+            className));
+        body.add(js.statement(
+            '#.as = function as_num(o) {'
+            '  if (typeof o == "number" || o == null) return o;'
+            '  return #.as(o, #, false);'
+            '}',
+            [className, _runtimeModule, className]));
+        body.add(js.statement(
+            '#._check = function check_num(o) {'
+            '  if (typeof o == "number" || o == null) return o;'
+            '  return #.as(o, #, true);'
+            '}',
+            [className, _runtimeModule, className]));
+        return null;
+      }
+      if (classElem == boolClass) {
+        body.add(js.statement(
+            '#.is = function is_bool(o) { return o === true || o === false; }',
+            className));
+        body.add(js.statement(
+            '#.as = function as_bool(o) {'
+            '  if (o === true || o === false || o == null) return o;'
+            '  return #.as(o, #, false);'
+            '}',
+            [className, _runtimeModule, className]));
+        body.add(js.statement(
+            '#._check = function check_bool(o) {'
+            '  if (o === true || o === false || o == null) return o;'
+            '  return #.as(o, #, true);'
+            '}',
+            [className, _runtimeModule, className]));
+        return null;
+      }
+    }
+    if (classElem.library.isDartAsync) {
+      if (classElem == types.futureOrType.element) {
+        var typeParamT = classElem.typeParameters[0].type;
+        var tOrFutureOfT = js.call('#.is(o) || #.is(o)', [
+          _emitType(typeParamT),
+          _emitType(types.futureType.instantiate([typeParamT]))
+        ]);
+        body.add(js.statement('''
+            #.is = function is_FutureOr(o) {
+              return #;
+            }
+            ''', [className, tOrFutureOfT]));
+        body.add(js.statement('''
+            #.as = function as_FutureOr(o) {
+              if (o == null || #) return o;
+              return #.castError(o, this, false);
+            }
+            ''', [className, tOrFutureOfT, _runtimeModule]));
+        body.add(js.statement('''
+            #._check = function check_FutureOr(o) {
+              if (o == null || #) return o;
+              return #.castError(o, this, true);

[Leaf, 2017/08/24 17:19:39]

Is there a reason the other cases above go through .as and this goes straight to
.castError?  Doesn't really matter since this is the slow path, but curious
whether there's a reason.

[Jennifer Messerly, 2017/08/24 18:26:37]

yeah, I'm trying to simplify things and have the complete check be implemented
whenever possible. If we fall back to the slow path, there's nothing to keep us
honest if our check didn't work. We'll see a perf degrade rather than a
functionality bug. 

I haven't had a chance to look at all of the others and change them yet, but
it's my eventual goal to do that, and remove the slow path entirely. 

+            }
+            ''', [className, tOrFutureOfT, _runtimeModule]));
+        return null;
+      }
+    }
+
+    body.add(_callHelperStatement('addTypeTests(#);', [className]));
+
+    if (classElem.typeParameters.isEmpty) return null;
+
+    // For generics, testing against the default instantiation is common,
+    // so optimize that.
+    var isClassSymbol = getInterfaceSymbol(classElem);
+    if (isClassSymbol == null) {
+      // TODO(jmesserly): we could export these symbols, if we want to mark
+      // implemented interfaces for user-defined classes.
+      var id = new JS.TemporaryId("_is_${classElem.name}_default");
+      _moduleItems.add(
+          js.statement('const # = Symbol(#);', [id, js.string(id.name, "'")]));
+      isClassSymbol = id;
+    }
+    // Marking every generic type instantiation as a subtype of its default
+    // instantiation.
+    markSubtypeOf(isClassSymbol);
+
+    // Define the type tests on the default instantiation to check for that
+    // marker.
+    var defaultInst = _emitTopLevelName(classElem);
+
+    // Return this `addTypeTests` call so we can emit it outside of the generic
+    // type parameter scope.
+    return _callHelperStatement(
+        'addTypeTests(#, #);', [defaultInst, isClassSymbol]);
   }
 
   void _emitSuperHelperSymbols(List<JS.Statement> body) {
     for (var id in _superHelpers.values.map((m) => m.name as JS.TemporaryId)) {
       body.add(js.statement('const # = Symbol(#)', [id, js.string(id.name)]));
     }
     _superHelpers.clear();
   }
 
   void _emitVirtualFieldSymbols(
@@ skipping 111 matching lines @@
     }
 
     var genericCall = _callHelper('generic(#)', [genericArgs]);
 
     if (element.library.isDartAsync &&
         (element.name == "Future" || element.name == "_Future")) {
       genericCall = _callHelper('flattenFutures(#)', [genericCall]);
     }
     var genericDef = js.statement(
         '# = #;', [_emitTopLevelName(element, suffix: r'$'), genericCall]);
+    // TODO(jmesserly): this should be instantiate to bounds
     var dynType = fillDynamicTypeArgs(element.type);
     var genericInst = _emitType(dynType, lowerGeneric: true);
     return js.statement(
         '{ #; # = #; }', [genericDef, _emitTopLevelName(element), genericInst]);
   }
 
   bool _deferIfNeeded(DartType type, ClassElement current) {
     if (type is ParameterizedType) {
       var typeArguments = type.typeArguments;
       for (var typeArg in typeArguments) {
@@ skipping 538 matching lines @@
     // We can ignore `noSuchMethod` because:
     // * `dynamic d; d();` without a declared `call` method is handled by dcall.
     // * for `class C implements Callable { noSuchMethod(i) { ... } }` we find
     //   the `call` method on the `Callable` interface.
     var callMethod = classElem.type.lookUpInheritedGetterOrMethod('call');
     bool isCallable = callMethod is PropertyAccessorElement
         ? callMethod.returnType is FunctionType
         : callMethod != null;
 
     var body = <JS.Statement>[];
+    if (isCallable) {
+      // Our class instances will have JS `typeof this == "function"`,
+      // so make sure to attach the runtime type information the same way
+      // we would do it for function types.
+      body.add(js.statement('#.prototype[#] = #;',
+          [className, _callHelper('_runtimeType'), className]));
+    }
+
     void addConstructor(ConstructorElement element, JS.Expression jsCtor) {
       var ctorName = _constructorName(element);
       if (JS.invalidStaticFieldName(element.name)) {
         jsCtor =
             _callHelper('defineValue(#, #, #)', [className, ctorName, jsCtor]);
       } else {
         jsCtor = js.call('#.# = #', [className, ctorName, jsCtor]);
       }
       body.add(js.statement('#.prototype = #.prototype;', [jsCtor, className]));
     }
@@ skipping 4139 matching lines @@
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = resolutionMap
       .elementDeclaredByCompilationUnit(target.root as CompilationUnit)
       .library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }