Move runtime js files down to lib/runtime/dart

lib/runtime/dart/_classes.js

 // 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 operations that define and manipulate Dart
  * classes.  Included in this are:
  *   - Generics
  *   - Class metadata
  *   - Extension methods
  */
 
 // TODO(leafp): Consider splitting some of this out.
-dart_library.library('dart_runtime/_classes', null, /* Imports */[
+dart_library.library('dart/_classes', null, /* Imports */[
 ], /* Lazy Imports */[
   'dart/core',
   'dart/_interceptors',
-  'dart_runtime/_types',
-  'dart_runtime/_rtti',
+  'dart/_types',
+  'dart/_rtti',
 ], function(exports, core, _interceptors, types, rtti) {
   'use strict';
 
   const assert = dart_utils.assert;
   const copyProperties = dart_utils.copyProperties;
   const copyTheseProperties = dart_utils.copyTheseProperties;
   const defineMemoizedGetter = dart_utils.defineMemoizedGetter;
   const safeGetOwnProperty = dart_utils.safeGetOwnProperty;
   const throwInternalError = dart_utils.throwInternalError;
 
   const defineProperty = Object.defineProperty;
   const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
   const getOwnPropertySymbols = Object.getOwnPropertySymbols;
 
-  const slice = [].slice;
-
   /** The Symbol for storing type arguments on a specialized generic type. */
   const _mixins = Symbol('mixins');
   const _implements = Symbol('implements');
   exports.implements = _implements;
   const _metadata = Symbol('metadata');
   exports.metadata = _metadata;
 
   /**
    * Returns a new type that mixes members from base and all mixins.
    *
    * Each mixin applies in sequence, with further to the right ones overriding
    * previous entries.
    *
    * For each mixin, we only take its own properties, not anything from its
    * superclass (prototype).
    */
-  function mixin(base/*, ...mixins*/) {
+  function mixin(base, ...mixins) {
     // Create an initializer for the mixin, so when derived constructor calls
     // super, we can correctly initialize base and mixins.
-    let mixins = slice.call(arguments, 1);
 
     // Create a class that will hold all of the mixin methods.
     class Mixin extends base {
       // Initializer method: run mixin initializers, then the base.
-      [base.name](/*...args*/) {
+      [base.name](...args) {
         // Run mixin initializers. They cannot have arguments.
         // Run them backwards so most-derived mixin is initialized first.
         for (let i = mixins.length - 1; i >= 0; i--) {
           let mixin = mixins[i];
           let init = mixin.prototype[mixin.name];
           if (init) init.call(this);
         }
         // Run base initializer.
         let init = base.prototype[base.name];
-        if (init) init.apply(this, arguments);
+        if (init) init.apply(this, args);
       }
     }
     // Copy each mixin's methods, with later ones overwriting earlier entries.
     for (let m of mixins) {
       copyProperties(Mixin.prototype, m.prototype);
     }
 
     // Set the signature of the Mixin class to be the composition
     // of the signatures of the mixins.
     setSignature(Mixin, {
@@ skipping 26 matching lines @@
   let _typeArguments = Symbol('typeArguments');
   let _originalDeclaration = Symbol('originalDeclaration');
 
   /** Memoize a generic type constructor function. */
   function generic(typeConstructor) {
     let length = typeConstructor.length;
     if (length < 1) {
       throwInternalError('must have at least one generic type argument');
     }
     let resultMap = new Map();
-    function makeGenericType(/*...arguments*/) {
-      if (arguments.length != length && arguments.length != 0) {
+    function makeGenericType(...args) {
+      if (args.length != length && args.length != 0) {
         throwInternalError('requires ' + length + ' or 0 type arguments');
       }
-      let args = slice.call(arguments);
       while (args.length < length) args.push(types.dynamic);
 
       let value = resultMap;
       for (let i = 0; i < length; i++) {
         let arg = args[i];
         if (arg == null) {
           throwInternalError('type arguments should not be null: '
                             + typeConstructor);
         }
         let map = value;
@@ skipping 228 matching lines @@
    *
    *     defineExtensionMembers(MyType, ['add', 'remove']);
    *
    * Results in:
    *
    *     MyType.prototype[dartx.add] = MyType.prototype.add;
    *     MyType.prototype[dartx.remove] = MyType.prototype.remove;
    */
   // TODO(jmesserly): essentially this gives two names to the same method.
   // This benefit is roughly equivalent call performance either way, but the
-  // cost is we need to call defineExtensionMembers any time a subclass 
+  // cost is we need to call defineExtensionMembers any time a subclass
   // overrides one of these methods.
   function defineExtensionMembers(type, methodNames) {
     let proto = type.prototype;
     for (let name of methodNames) {
       let method = getOwnPropertyDescriptor(proto, name);
       defineProperty(proto, getExtensionSymbol(name), method);
     }
     // Ensure the signature is available too.
     // TODO(jmesserly): not sure if we can do this in a cleaner way. Essentially
     // we need to copy the signature (and in the future, other data like
@@ skipping 33 matching lines @@
   }
   exports.list = list;
 
   function setBaseClass(derived, base) {
     // Link the extension to the type it's extending as a base class.
     derived.prototype.__proto__ = base.prototype;
   }
   exports.setBaseClass = setBaseClass;
 
 });