Reorganize tool/input_sdk/private

tool/input_sdk/private/types.dart

Index: tool/input_sdk/private/types.dart
diff --git a/tool/input_sdk/private/types.dart b/tool/input_sdk/private/types.dart
deleted file mode 100644
index ec99cf99bfe4e073de115f42bc5ff49302f4270f..0000000000000000000000000000000000000000
--- a/tool/input_sdk/private/types.dart
+++ /dev/null
@@ -1,546 +0,0 @@
-// 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.
-
-/// This library defines the representation of runtime types.
-part of dart._runtime;
-
-/// The Symbol for storing type arguments on a specialized generic type.
-final _mixins = JS('', 'Symbol("mixins")');
-@JSExportName('implements')
-final implements_ = JS('', 'Symbol("implements")');
-final metadata = JS('', 'Symbol("metadata")');
-
-
-///
-/// Types in dart are represented at runtime as follows.
-///   - Normal nominal types, produced from classes, are represented
-///     at runtime by the JS class of which they are an instance.
-///     If the type is the result of instantiating a generic class,
-///     then the "classes" module manages the association between the
-///     instantiated class and the original class declaration
-///     and the type arguments with which it was instantiated.  This
-///     assocation can be queried via the "classes" module".
-///
-///   - All other types are represented as instances of class TypeRep,
-///     defined in this module.
-///     - Dynamic, Void, and Bottom are singleton instances of sentinal
-///       classes.
-///     - Function types are instances of subclasses of AbstractFunctionType.
-///
-/// Function types are represented in one of two ways:
-///   - As an instance of FunctionType.  These are eagerly computed.
-///   - As an instance of TypeDef.  The TypeDef representation lazily
-///     computes an instance of FunctionType, and delegates to that instance.
-///
-/// All types satisfy the following interface:
-///  get String name;
-///  String toString();
-///
-///
-final _TypeRepBase = JS('', '$LazyTagged(() => $Type)');
-final TypeRep = JS('', '''
-  class TypeRep extends $_TypeRepBase {
-    get name() {return this.toString();}
-  }
-''');
-
-final Dynamic = JS('', '''
-  class Dynamic extends $TypeRep {
-    toString() { return "dynamic"; }
-  }
-''');
-@JSExportName('dynamic')
-final dynamicR = JS('', 'new $Dynamic()');
-
-final Void = JS('', '''
-  class Void extends $TypeRep {
-    toString() { return "void"; }
-  }
-''');
-@JSExportName('void')
-final voidR = JS('', 'new $Void()');
-
-final Bottom = JS('', '''
-  class Bottom extends $TypeRep {
-    toString() { return "bottom"; }
-  }
-''');
-final bottom = JS('', 'new $Bottom()');
-
-final JSObject = JS('', '''
-  class JSObject extends $TypeRep {
-    toString() { return "NativeJavaScriptObject"; }
-  }
-''');
-final jsobject = JS('', 'new $JSObject()');
-
-final AbstractFunctionType = JS('', '''
-  class AbstractFunctionType extends $TypeRep {
-    constructor() {
-      super();
-      this._stringValue = null;
-    }
-
-    toString() { return this.name; }
-
-    get name() {
-      if (this._stringValue) return this._stringValue;
-
-      let buffer = '(';
-      for (let i = 0; i < this.args.length; ++i) {
-        if (i > 0) {
-          buffer += ', ';
-        }
-        buffer += $typeName(this.args[i]);
-      }
-      if (this.optionals.length > 0) {
-        if (this.args.length > 0) buffer += ', ';
-        buffer += '[';
-        for (let i = 0; i < this.optionals.length; ++i) {
-          if (i > 0) {
-            buffer += ', ';
-          }
-          buffer += $typeName(this.optionals[i]);
-        }
-        buffer += ']';
-      } else if (Object.keys(this.named).length > 0) {
-        if (this.args.length > 0) buffer += ', ';
-        buffer += '{';
-        let names = $getOwnPropertyNames(this.named).sort();
-        for (let i = 0; i < names.length; ++i) {
-          if (i > 0) {
-            buffer += ', ';
-          }
-          buffer += names[i] + ': ' + $typeName(this.named[names[i]]);
-        }
-        buffer += '}';
-      }
-
-      buffer += ') -> ' + $typeName(this.returnType);
-      this._stringValue = buffer;
-      return buffer;
-    }
-  }
-''');
-
-final FunctionType = JS('', '''
-  class FunctionType extends $AbstractFunctionType {
-    /**
-     * Construct a function type. There are two arrow constructors,
-     * distinguished by the "definite" flag.
-     *
-     * The fuzzy arrow (definite is false) treats any arguments
-     * of type dynamic as having type bottom, and will always be
-     * called with a dynamic invoke.
-     *
-     * The definite arrow (definite is true) leaves arguments unchanged.
-     *
-     * We eagerly canonize the argument types to avoid having to deal with
-     * this logic in multiple places.
-     *
-     * TODO(leafp): Figure out how to present this to the user.  How
-     * should these be printed out?
-     */
-    constructor(definite, returnType, args, optionals, named) {
-      super();
-      this.definite = definite;
-      this.returnType = returnType;
-      this.args = args;
-      this.optionals = optionals;
-      this.named = named;
-
-      // TODO(vsm): This is just parameter metadata for now.
-      this.metadata = [];
-      function process(array, metadata) {
-        var result = [];
-        for (var i = 0; i < array.length; ++i) {
-          var arg = array[i];
-          if (arg instanceof Array) {
-            metadata.push(arg.slice(1));
-            result.push(arg[0]);
-          } else {
-            metadata.push([]);
-            result.push(arg);
-          }
-        }
-        return result;
-      }
-      this.args = process(this.args, this.metadata);
-      this.optionals = process(this.optionals, this.metadata);
-      // TODO(vsm): Add named arguments.
-      this._canonize();
-    }
-    _canonize() {
-      if (this.definite) return;
-
-      function replace(a) {
-        return (a == $dynamicR) ? $bottom : a;
-      }
-
-      this.args = this.args.map(replace);
-
-      if (this.optionals.length > 0) {
-        this.optionals = this.optionals.map(replace);
-      }
-
-      if (Object.keys(this.named).length > 0) {
-        let r = {};
-        for (let name of $getOwnPropertyNames(this.named)) {
-          r[name] = replace(this.named[name]);
-        }
-        this.named = r;
-      }
-    }
-  }
-''');
-
-final Typedef = JS('', '''
-  class Typedef extends $AbstractFunctionType {
-    constructor(name, closure) {
-      super();
-      this._name = name;
-      this._closure = closure;
-      this._functionType = null;
-    }
-
-    get definite() {
-      return this._functionType.definite;
-    }
-
-    get name() {
-      return this._name;
-    }
-
-    get functionType() {
-      if (!this._functionType) {
-        this._functionType = this._closure();
-      }
-      return this._functionType;
-    }
-
-    get returnType() {
-      return this.functionType.returnType;
-    }
-
-    get args() {
-      return this.functionType.args;
-    }
-
-    get optionals() {
-      return this.functionType.optionals;
-    }
-
-    get named() {
-      return this.functionType.named;
-    }
-
-    get metadata() {
-      return this.functionType.metadata;
-    }
-  }
-''');
-
-_functionType(definite, returnType, args, extra) => JS('', '''(() => {
-  // TODO(vsm): Cache / memomize?
-  let optionals;
-  let named;
-  if ($extra === void 0) {
-    optionals = [];
-    named = {};
-  } else if ($extra instanceof Array) {
-    optionals = $extra;
-    named = {};
-  } else {
-    optionals = [];
-    named = $extra;
-  }
-  return new $FunctionType($definite, $returnType, $args, optionals, named);
-})()''');
-
-///
-/// Create a "fuzzy" function type.  If any arguments are dynamic
-/// they will be replaced with bottom.
-///
-functionType(returnType, args, extra) => JS('', '''(() => {
-  return $_functionType(false, $returnType, $args, $extra);
-})()''');
-
-///
-/// Create a definite function type. No substitution of dynamic for
-/// bottom occurs.
-///
-definiteFunctionType(returnType, args, extra) => JS('', '''(() => {
-  return $_functionType(true, $returnType, $args, $extra);
-})()''');
-
-typedef(name, closure) => JS('', '''(() => {
-  return new $Typedef($name, $closure);
-})()''');
-
-isDartType(type) => JS('', '''(() => {
-  return $read($type) === $Type;
-})()''');
-
-typeName(type) => JS('', '''(() => {
-  // Non-instance types
-  if ($type instanceof $TypeRep) return $type.toString();
-  // Instance types
-  let tag = $read($type);
-  if (tag === $Type) {
-    let name = $type.name;
-    let args = $getGenericArgs($type);
-    if (args) {
-      name += '<';
-      for (let i = 0; i < args.length; ++i) {
-        if (i > 0) name += ', ';
-        name += $typeName(args[i]);
-      }
-      name += '>';
-    }
-    return name;
-  }
-  if (tag) return "Not a type: " + tag.name;
-  return "JSObject<" + $type.name + ">";
-})()''');
-
-isFunctionType(type) => JS('', '''(() => {
-  return $type instanceof $AbstractFunctionType || $type == $Function;
-})()''');
-
-isFunctionSubType(ft1, ft2) => JS('', '''(() => {
-  if ($ft2 == $Function) {
-    return true;
-  }
-
-  let ret1 = $ft1.returnType;
-  let ret2 = $ft2.returnType;
-
-  if (!$isSubtype_(ret1, ret2)) {
-    // Covariant return types
-    // Note, void (which can only appear as a return type) is effectively
-    // treated as dynamic.  If the base return type is void, we allow any
-    // subtype return type.
-    // E.g., we allow:
-    //   () -> int <: () -> void
-    if (ret2 != $voidR) {
-      return false;
-    }
-  }
-
-  let args1 = $ft1.args;
-  let args2 = $ft2.args;
-
-  if (args1.length > args2.length) {
-    return false;
-  }
-
-  for (let i = 0; i < args1.length; ++i) {
-    if (!$isSubtype_(args2[i], args1[i])) {
-      return false;
-    }
-  }
-
-  let optionals1 = $ft1.optionals;
-  let optionals2 = $ft2.optionals;
-
-  if (args1.length + optionals1.length < args2.length + optionals2.length) {
-    return false;
-  }
-
-  let j = 0;
-  for (let i = args1.length; i < args2.length; ++i, ++j) {
-    if (!$isSubtype_(args2[i], optionals1[j])) {
-      return false;
-    }
-  }
-
-  for (let i = 0; i < optionals2.length; ++i, ++j) {
-    if (!$isSubtype_(optionals2[i], optionals1[j])) {
-      return false;
-    }
-  }
-
-  let named1 = $ft1.named;
-  let named2 = $ft2.named;
-
-  let names = $getOwnPropertyNames(named2);
-  for (let i = 0; i < names.length; ++i) {
-    let name = names[i];
-    let n1 = named1[name];
-    let n2 = named2[name];
-    if (n1 === void 0) {
-      return false;
-    }
-    if (!$isSubtype_(n2, n1)) {
-      return false;
-    }
-  }
-
-  return true;
-})()''');
-
-///
-/// Computes the canonical type.
-/// This maps JS types onto their corresponding Dart Type.
-///
-// TODO(jmesserly): lots more needs to be done here.
-canonicalType(t) => JS('', '''(() => {
-  if ($t === Object) return $Object;
-  if ($t === Function) return $Function;
-  if ($t === Array) return $List;
-
-  // We shouldn't normally get here with these types, unless something strange
-  // happens like subclassing Number in JS and passing it to Dart.
-  if ($t === String) return $String;
-  if ($t === Number) return $double;
-  if ($t === Boolean) return $bool;
-  return $t;
-})()''');
-
-final subtypeMap = JS('', 'new Map()');
-isSubtype(t1, t2) => JS('', '''(() => {
-  // See if we already know the answer
-  // TODO(jmesserly): general purpose memoize function?
-  let map = $subtypeMap.get($t1);
-  let result;
-  if (map) {
-    result = map.get($t2);
-    if (result !== void 0) return result;
-  } else {
-    $subtypeMap.set($t1, map = new Map());
-  }
-  result = $isSubtype_($t1, $t2);
-  map.set($t2, result);
-  return result;
-})()''');
-
-_isBottom(type) => JS('', '''(() => {
-  return $type == $bottom;
-})()''');
-
-_isTop(type) => JS('', '''(() => {
-  return $type == $Object || ($type == $dynamicR);
-})()''');
-
-isSubtype_(t1, t2) => JS('', '''(() => {
-  $t1 = $canonicalType($t1);
-  $t2 = $canonicalType($t2);
-  if ($t1 == $t2) return true;
-
-  // Trivially true.
-  if ($_isTop($t2) || $_isBottom($t1)) {
-    return true;
-  }
-
-  // Trivially false.
-  if ($_isTop($t1) || $_isBottom($t2)) {
-    return false;
-  }
-
-  // "Traditional" name-based subtype check.
-  if ($isClassSubType($t1, $t2)) {
-    return true;
-  }
-
-  // Function subtyping.
-  // TODO(vsm): Handle Objects with call methods.  Those are functions
-  // even if they do not *nominally* subtype core.Function.
-  if ($isFunctionType($t1) &&
-      $isFunctionType($t2)) {
-    return $isFunctionSubType($t1, $t2);
-  }
-  return false;
-})()''');
-
-isClassSubType(t1, t2) => JS('', '''(() => {
-  // We support Dart's covariant generics with the caveat that we do not
-  // substitute bottom for dynamic in subtyping rules.
-  // I.e., given T1, ..., Tn where at least one Ti != dynamic we disallow:
-  // - S !<: S<T1, ..., Tn>
-  // - S<dynamic, ..., dynamic> !<: S<T1, ..., Tn>
-  $t1 = $canonicalType($t1);
-  $assert_($t2 == $canonicalType($t2));
-  if ($t1 == $t2) return true;
-
-  if ($t1 == $Object) return false;
-
-  // If t1 is a JS Object, we may not hit core.Object.
-  if ($t1 == null) return $t2 == $Object || $t2 == $dynamicR;
-
-  // Check if t1 and t2 have the same raw type.  If so, check covariance on
-  // type parameters.
-  let raw1 = $getGenericClass($t1);
-  let raw2 = $getGenericClass($t2);
-  if (raw1 != null && raw1 == raw2) {
-    let typeArguments1 = $getGenericArgs($t1);
-    let typeArguments2 = $getGenericArgs($t2);
-    let length = typeArguments1.length;
-    if (typeArguments2.length == 0) {
-      // t2 is the raw form of t1
-      return true;
-    } else if (length == 0) {
-      // t1 is raw, but t2 is not
-      return false;
-    }
-    $assert_(length == typeArguments2.length);
-    for (let i = 0; i < length; ++i) {
-      if (!$isSubtype(typeArguments1[i], typeArguments2[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  // Check superclass.
-  if ($isClassSubType($t1.__proto__, $t2)) return true;
-
-  // Check mixins.
-  let mixins = $getMixins($t1);
-  if (mixins) {
-    for (let m1 of mixins) {
-      // TODO(jmesserly): remove the != null check once we can load core libs.
-      if (m1 != null && $isClassSubType(m1, $t2)) return true;
-    }
-  }
-
-  // Check interfaces.
-  let getInterfaces = $getImplements($t1);
-  if (getInterfaces) {
-    for (let i1 of getInterfaces()) {
-      // TODO(jmesserly): remove the != null check once we can load core libs.
-      if (i1 != null && $isClassSubType(i1, $t2)) return true;
-    }
-  }
-
-  return false;
-})()''');
-
-// TODO(jmesserly): this isn't currently used, but it could be if we want
-// `obj is NonGroundType<T,S>` to be rejected at runtime instead of compile
-// time.
-isGroundType(type) => JS('', '''(() => {
-  // TODO(vsm): Cache this if we start using it at runtime.
-
-  if ($type instanceof $AbstractFunctionType) {
-    if (!$_isTop($type.returnType)) return false;
-    for (let i = 0; i < $type.args.length; ++i) {
-      if (!$_isBottom($type.args[i])) return false;
-    }
-    for (let i = 0; i < $type.optionals.length; ++i) {
-      if (!$_isBottom($type.optionals[i])) return false;
-    }
-    let names = $getOwnPropertyNames($type.named);
-    for (let i = 0; i < names.length; ++i) {
-      if (!$_isBottom($type.named[names[i]])) return false;
-    }
-    return true;
-  }
-
-  let typeArgs = $getGenericArgs($type);
-  if (!typeArgs) return true;
-  for (let t of typeArgs) {
-    if (t != $Object && t != $dynamicR) return false;
-  }
-  return true;
-})()''');