Restrict backend misuse

pkg/compiler/lib/src/js_backend/backend_impact.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.
 
 library dart2js.js_helpers.impact;
 
 import '../common/names.dart' show
     Identifiers;
 import '../compiler.dart' show
     Compiler;
@@ skipping 50 matching lines @@
   BackendImpact _computeSignature;
 
   BackendImpact get computeSignature {
     if (_computeSignature == null) {
       _computeSignature = new BackendImpact(
           staticUses: [
             helpers.setRuntimeTypeInfo,
             helpers.getRuntimeTypeInfo,
             helpers.computeSignature,
             helpers.getRuntimeTypeArguments],
-          instantiatedClasses: [
-            coreClasses.listClass]);
+          otherImpacts: [
+            listValues]);
     }
     return _computeSignature;
   }
 
   BackendImpact _asyncBody;
 
   BackendImpact get asyncBody {
     if (_asyncBody == null) {
       _asyncBody = new BackendImpact(
           staticUses: [
@@ skipping 97 matching lines @@
           otherImpacts: [
             // Also register the types of the arguments passed to this method.
             _needsList(
                 'Needed to encode the arguments for throw NoSuchMethodError.'),
             _needsString(
                 'Needed to encode the name for throw NoSuchMethodError.')]);
     }
     return _throwNoSuchMethod;
   }
 
+  BackendImpact _stringValues;
+
+  BackendImpact get stringValues {
+    if (_stringValues == null) {
+      _stringValues = new BackendImpact(
+          instantiatedClasses: [
+            helpers.jsStringClass]);
+    }
+    return _stringValues;
+  }
+
+  BackendImpact _numValues;
+
+  BackendImpact get numValues {
+    if (_numValues == null) {
+      _numValues = new BackendImpact(
+          instantiatedClasses: [
+            helpers.jsIntClass,
+            helpers.jsPositiveIntClass,
+            helpers.jsUInt32Class,
+            helpers.jsUInt31Class,
+            helpers.jsNumberClass,
+            helpers.jsDoubleClass]);
+    }
+    return _numValues;
+  }
+
+  BackendImpact get intValues => numValues;
+
+  BackendImpact get doubleValues => numValues;
+
+  BackendImpact _boolValues;
+
+  BackendImpact get boolValues {
+    if (_boolValues == null) {
+      _boolValues = new BackendImpact(
+          instantiatedClasses: [
+            helpers.jsBoolClass]);
+    }
+    return _boolValues;
+  }
+
+  BackendImpact _nullValue;
+
+  BackendImpact get nullValue {
+    if (_nullValue == null) {
+      _nullValue = new BackendImpact(
+          instantiatedClasses: [
+            helpers.jsNullClass]);
+    }
+    return _nullValue;
+  }
+
+  BackendImpact _listValues;
+
+  BackendImpact get listValues {
+    if (_listValues == null) {
+      _listValues = new BackendImpact(
+          instantiatedClasses: [
+            helpers.jsArrayClass,
+            helpers.jsMutableArrayClass,
+            helpers.jsFixedArrayClass,
+            helpers.jsExtendableArrayClass,
+            helpers.jsUnmodifiableArrayClass]);
+    }
+    return _listValues;
+  }
+
   BackendImpact _throwRuntimeError;
 
   BackendImpact get throwRuntimeError {
     if (_throwRuntimeError == null) {
       _throwRuntimeError = new BackendImpact(
           staticUses: [
             helpers.throwRuntimeError],
-          // Also register the types of the arguments passed to this method.
-          instantiatedClasses: [
-            coreClasses.stringClass]);
+          otherImpacts: [
+            // Also register the types of the arguments passed to this method.
+            stringValues]);
     }
     return _throwRuntimeError;
   }
 
   BackendImpact _superNoSuchMethod;
 
   BackendImpact get superNoSuchMethod {
     if (_superNoSuchMethod == null) {
       _superNoSuchMethod = new BackendImpact(
           staticUses: [
             helpers.createInvocationMirror,
-            coreClasses.objectClass.lookupLocalMember(
-                Identifiers.noSuchMethod_)],
+            helpers.objectNoSuchMethod],
           otherImpacts: [
             _needsInt(
                 'Needed to encode the invocation kind of super.noSuchMethod.'),
             _needsList(
                 'Needed to encode the arguments of super.noSuchMethod.'),
             _needsString(
                 'Needed to encode the name of super.noSuchMethod.')]);
     }
     return _superNoSuchMethod;
   }
@@ skipping 47 matching lines @@
     if (_incDecOperation == null) {
       _incDecOperation =
           _needsInt('Needed for the `+ 1` or `- 1` operation of ++/--.');
     }
     return _incDecOperation;
   }
 
   /// Helper for registering that `int` is needed.
   BackendImpact _needsInt(String reason) {
     // TODO(johnniwinther): Register [reason] for use in dump-info.
-    return new BackendImpact(
-        instantiatedClasses: [coreClasses.intClass]);
+    return intValues;
   }
 
   /// Helper for registering that `List` is needed.
   BackendImpact _needsList(String reason) {
     // TODO(johnniwinther): Register [reason] for use in dump-info.
-    return new BackendImpact(
-        instantiatedClasses: [coreClasses.listClass]);
+    return listValues;
   }
 
   /// Helper for registering that `String` is needed.
   BackendImpact _needsString(String reason) {
     // TODO(johnniwinther): Register [reason] for use in dump-info.
-    return new BackendImpact(
-        instantiatedClasses: [
-          coreClasses.stringClass]);
+    return stringValues;
   }
 
   BackendImpact _assertWithoutMessage;
 
   BackendImpact get assertWithoutMessage {
     if (_assertWithoutMessage == null) {
       _assertWithoutMessage = new BackendImpact(
           staticUses: [
             helpers.assertHelper]);
     }
@@ skipping 38 matching lines @@
 
   BackendImpact _stringJuxtaposition;
 
   BackendImpact get stringJuxtaposition {
     if (_stringJuxtaposition == null) {
       _stringJuxtaposition = _needsString('String.concat is used.');
     }
     return _stringJuxtaposition;
   }
 
-  // TODO(johnniwinther): Point to to the JavaScript classes instead of the Dart
-  // classes in these impacts.
-  BackendImpact _nullLiteral;
+  BackendImpact get nullLiteral => nullValue;
 
-  BackendImpact get nullLiteral {
-    if (_nullLiteral == null) {
-      _nullLiteral = new BackendImpact(
-          instantiatedClasses: [
-            coreClasses.nullClass]);
-    }
-    return _nullLiteral;
-  }
+  BackendImpact get boolLiteral => boolValues;
 
-  BackendImpact _boolLiteral;
+  BackendImpact get intLiteral => intValues;
 
-  BackendImpact get boolLiteral {
-    if (_boolLiteral == null) {
-      _boolLiteral = new BackendImpact(
-          instantiatedClasses: [
-            coreClasses.boolClass]);
-    }
-    return _boolLiteral;
-  }
+  BackendImpact get doubleLiteral => doubleValues;
 
-  BackendImpact _intLiteral;
-
-  BackendImpact get intLiteral {
-    if (_intLiteral == null) {
-      _intLiteral = new BackendImpact(
-          instantiatedClasses: [
-            coreClasses.intClass]);
-    }
-    return _intLiteral;
-  }
-
-  BackendImpact _doubleLiteral;
-
-  BackendImpact get doubleLiteral {
-    if (_doubleLiteral == null) {
-      _doubleLiteral = new BackendImpact(
-          instantiatedClasses: [
-            coreClasses.doubleClass]);
-    }
-    return _doubleLiteral;
-  }
-
-  BackendImpact _stringLiteral;
-
-  BackendImpact get stringLiteral {
-    if (_stringLiteral == null) {
-      _stringLiteral = new BackendImpact(
-          instantiatedClasses: [
-            coreClasses.stringClass]);
-    }
-    return _stringLiteral;
-  }
+  BackendImpact get stringLiteral => stringValues;
 
   BackendImpact _catchStatement;
 
   BackendImpact get catchStatement {
     if (_catchStatement == null) {
       _catchStatement = new BackendImpact(
           staticUses: [
             helpers.exceptionUnwrapper],
           instantiatedClasses: [
             helpers.jsPlainJavaScriptObjectClass,
@@ skipping 40 matching lines @@
     }
     return _typeLiteral;
   }
 
   BackendImpact _stackTraceInCatch;
 
   BackendImpact get stackTraceInCatch {
     if (_stackTraceInCatch == null) {
       _stackTraceInCatch = new BackendImpact(
           instantiatedClasses: [
-            coreClasses.stackTraceClass],
+            helpers.stackTraceClass],
           staticUses: [
             helpers.traceFromException]);
     }
     return _stackTraceInCatch;
   }
 
   BackendImpact _syncForIn;
 
   BackendImpact get syncForIn {
     if (_syncForIn == null) {
       _syncForIn = new BackendImpact(
           // The SSA builder recognizes certain for-in loops and can generate
           // calls to throwConcurrentModificationError.
           staticUses: [
             helpers.checkConcurrentModificationError]);
     }
     return _syncForIn;
   }
 
   BackendImpact _typeVariableExpression;
 
   BackendImpact get typeVariableExpression {
     if (_typeVariableExpression == null) {
       _typeVariableExpression = new BackendImpact(
           staticUses: [
             helpers.setRuntimeTypeInfo,
             helpers.getRuntimeTypeInfo,
             helpers.runtimeTypeToString,
             helpers.createRuntimeType],
-          instantiatedClasses: [
-            coreClasses.listClass],
           otherImpacts: [
+            listValues,
             getRuntimeTypeArgument,
             _needsInt('Needed for accessing a type variable literal on this.')
           ]);
     }
     return _typeVariableExpression;
   }
 
   BackendImpact _typeCheck;
 
   BackendImpact get typeCheck {
     if (_typeCheck == null) {
       _typeCheck = new BackendImpact(
-          instantiatedClasses: [
-            coreClasses.boolClass]);
+          otherImpacts: [
+            boolValues]);
     }
     return _typeCheck;
   }
 
   BackendImpact _checkedModeTypeCheck;
 
   BackendImpact get checkedModeTypeCheck {
     if (_checkedModeTypeCheck == null) {
       _checkedModeTypeCheck = new BackendImpact(
           staticUses: [
@@ skipping 16 matching lines @@
   BackendImpact _genericTypeCheck;
 
   BackendImpact get genericTypeCheck {
     if (_genericTypeCheck == null) {
       _genericTypeCheck = new BackendImpact(
           staticUses: [
             helpers.checkSubtype,
             // TODO(johnniwinther): Investigate why this is needed.
             helpers.setRuntimeTypeInfo,
             helpers.getRuntimeTypeInfo],
-          instantiatedClasses: [
-            coreClasses.listClass],
           otherImpacts: [
+            listValues,
             getRuntimeTypeArgument]);
     }
     return _genericTypeCheck;
   }
 
   BackendImpact _genericIsCheck;
 
   BackendImpact get genericIsCheck {
     if (_genericIsCheck == null) {
       _genericIsCheck = new BackendImpact(
-          instantiatedClasses: [
-            coreClasses.listClass]);
+          otherImpacts: [
+            intValues]);
     }
     return _genericIsCheck;
   }
 
   BackendImpact _genericCheckedModeTypeCheck;
 
   BackendImpact get genericCheckedModeTypeCheck {
     if (_genericCheckedModeTypeCheck == null) {
       _genericCheckedModeTypeCheck = new BackendImpact(
           staticUses: [
@@ skipping 53 matching lines @@
 
   BackendImpact get closure {
     if (_closure == null) {
       _closure = new BackendImpact(
           instantiatedClasses: [
             coreClasses.functionClass]);
     }
     return _closure;
   }
 }