Enable is and as checks on non-ground types

lib/runtime/_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 */[
 ], /* Lazy Imports */[
   'dart/core',
   'dart/_interceptors',
   'dart_runtime/_types',
   'dart_runtime/_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 throwError = dart_utils.throwError;
+  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');
@@ skipping 65 matching lines @@
   exports.getImplements = getImplements;
 
   /** The Symbol for storing type arguments on a specialized generic type. */
   let _typeArguments = Symbol('typeArguments');
   let _originalDeclaration = Symbol('originalDeclaration');
 
   /** Memoize a generic type constructor function. */
   function generic(typeConstructor) {
     let length = typeConstructor.length;
     if (length < 1) {
-      throwError('must have at least one generic type argument');
+      throwInternalError('must have at least one generic type argument');
     }
     let resultMap = new Map();
     function makeGenericType(/*...arguments*/) {
       if (arguments.length != length && arguments.length != 0) {
-        throwError('requires ' + length + ' or 0 type arguments');
+        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) {
-          throwError('type arguments should not be null: '
+          throwInternalError('type arguments should not be null: '
                             + typeConstructor);
         }
         let map = value;
         value = map.get(arg);
         if (value === void 0) {
           if (i + 1 == length) {
             value = typeConstructor.apply(null, args);
             // Save the type constructor and arguments for reflection.
             if (value) {
               value[_typeArguments] = args;
@@ skipping 261 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;
 
 });