dart2js: Allow to encode side-effects in the spec-string of JS and similar built-ins.

tests/compiler/dart2js/js_spec_string_test.dart

 // Copyright (c) 2014, 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.
 
 // Unit test of the [NativeBehavior.processSpecString] method.
 
 import 'package:expect/expect.dart';
 import 'package:compiler/src/native/native.dart';
 import 'package:compiler/src/dart2jslib.dart'
     show DiagnosticListener;
+import 'package:compiler/src/universe/universe.dart'
+    show SideEffects;
 
 const OBJECT = 'Object';
 const NULL = 'Null';
 
 class Listener implements DiagnosticListener {
   String errorMessage;
-  internalError(spannable, message) => errorMessage = message;
+  internalError(spannable, message) {
+    errorMessage = message;
+    throw "error";
+  }
 
   noSuchMethod(_) => null;
 }
 
 void test(String specString,
           {List returns,
            List creates,
+           SideEffects expectedSideEffects,
            bool expectError: false}) {
   List actualReturns = [];
   List actualCreates = [];
+  SideEffects actualSideEffects;
   Listener listener = new Listener();
-  NativeBehavior.processSpecString(
-      listener,
-      null,
-      specString,
-      resolveType: (t) => t,
-      typesReturned: actualReturns, typesInstantiated: actualCreates,
-      objectType: OBJECT, nullType: NULL);
-  if (expectError) {
+  try {
+    NativeBehavior.processSpecString(
+        listener,
+        null,
+        specString,
+        setSideEffects: (effects) { actualSideEffects = effects; },
+        resolveType: (t) => t,
+        typesReturned: actualReturns, typesInstantiated: actualCreates,
+        objectType: OBJECT, nullType: NULL);
+  } catch (e) {
+    Expect.isTrue(expectError);
     Expect.isNotNull(listener.errorMessage, 'Internal error expected.');
-  } else {
-    Expect.isNull(listener.errorMessage, 'Unexpected internal error.');
-    Expect.listEquals(returns, actualReturns, 'Unexpected returns.');
-    Expect.listEquals(creates, actualCreates, 'Unexpected creates.');
+    return;
   }
+  Expect.isNull(listener.errorMessage, 'Unexpected internal error.');
+  Expect.listEquals(returns, actualReturns, 'Unexpected returns.');
+  Expect.listEquals(creates, actualCreates, 'Unexpected creates.');
+  Expect.equals(expectedSideEffects, actualSideEffects);
+}
+
+void testWithSideEffects(String specString,
+                          {List returns,
+                           List creates,
+                           bool expectError: false}) {
+
+  void sideEffectsTest(String newSpecString, SideEffects expectedSideEffects,
+                       {bool sideEffectsExpectError}) {
+    test(newSpecString,
+         returns: returns,
+         creates: creates,
+         expectedSideEffects: expectedSideEffects,
+         expectError: sideEffectsExpectError == null
+             ? expectError
+             : sideEffectsExpectError);
+  }
+
+  SideEffects emptySideEffects = new SideEffects.empty();
+  sideEffectsTest(specString + "effects:empty;depends:empty;",
+                  emptySideEffects);
+  sideEffectsTest(specString + "depends:empty;effects:empty;",
+                  emptySideEffects);
+  sideEffectsTest("effects:empty;depends:empty;" + specString,
+                  emptySideEffects);
+  sideEffectsTest("depends:empty;effects:empty;" + specString,
+                  emptySideEffects);
+
+  SideEffects effects = new SideEffects();
+  effects.clearChangesIndex();
+  effects.clearAllDependencies();
+  sideEffectsTest(specString + "effects:-index;depends:empty;", effects);
+
+  effects = new SideEffects();
+  effects.clearAllSideEffects();
+  effects.clearDependsOnIndexStore();
+  sideEffectsTest(specString + "effects:empty;depends:-index;", effects);
+
+  effects = new SideEffects();
+  effects.clearChangesInstanceProperty();
+  effects.clearChangesStaticProperty();
+  effects.clearAllDependencies();
+  sideEffectsTest(specString + "effects:-instance,-static;depends:empty;",
+                  effects);
+
+  effects = new SideEffects();
+  effects.clearAllSideEffects();
+  effects.clearDependsOnInstancePropertyStore();
+  effects.clearDependsOnStaticPropertyStore();
+  sideEffectsTest(specString + "effects:empty;depends:-instance,-static;",
+                  effects);
+
+  effects = new SideEffects();
+  effects.clearChangesInstanceProperty();
+  effects.clearChangesStaticProperty();
+  effects.clearDependsOnIndexStore();
+  sideEffectsTest(specString + "effects:-instance,-static;depends:-index;",
+                  effects);
+
+  effects = new SideEffects();
+  effects.clearChangesIndex();
+  effects.clearDependsOnInstancePropertyStore();
+  effects.clearDependsOnStaticPropertyStore();
+  sideEffectsTest(specString + "effects:-index;depends:-instance,-static;",
+                  effects);
+
+  effects = new SideEffects();
+  effects.clearChangesIndex();
+  sideEffectsTest(specString + "effects:-index;depends:all;", effects);
+
+  effects = new SideEffects();
+  effects.clearDependsOnIndexStore();
+  sideEffectsTest(specString + "effects:all;depends:-index;", effects);
+
+  effects = new SideEffects();
+  effects.clearChangesInstanceProperty();
+  effects.clearChangesStaticProperty();
+  sideEffectsTest(specString + "effects:-instance,-static;depends:all;",
+                  effects);
+
+  effects = new SideEffects();
+  effects.clearDependsOnInstancePropertyStore();
+  effects.clearDependsOnStaticPropertyStore();
+  sideEffectsTest(specString + "effects:all;depends:-instance,-static;",
+                  effects);
+
+  sideEffectsTest(specString + "effects:-instance,-static;",
+                  effects,
+                  sideEffectsExpectError: true);
+
+  sideEffectsTest(specString + "depends:-instance,-static;",
+                  effects,
+                  sideEffectsExpectError: true);
+
+  sideEffectsTest(specString + "effects:empty;",
+                  effects,
+                  sideEffectsExpectError: true);
+
+  sideEffectsTest(specString + "depends:all;",
+                  effects,
+                  sideEffectsExpectError: true);
+
+  sideEffectsTest(specString + "effects:-instance,-static;depends:foo;",
+                  effects,
+                  sideEffectsExpectError: true);
+
+  sideEffectsTest(specString + "effects:foo;depends:-instance,-static;",
+                  effects,
+                  sideEffectsExpectError: true);
+
+  sideEffectsTest(specString + "effects:all;depends:foo",
+                  effects,
+                  sideEffectsExpectError: true);
+
+  sideEffectsTest(specString + "effects:foo;depends:empty;",
+                  effects,
+                  sideEffectsExpectError: true);
+
+  sideEffectsTest(specString + "effects:;depends:empty;",
+                  effects,
+                  sideEffectsExpectError: true);
+
+  sideEffectsTest(specString + "effects:all;depends:;",
+                  effects,
+                  sideEffectsExpectError: true);
 }
 
 void main() {
   test('void', returns: [], creates: []);
   test('', returns: [OBJECT, NULL], creates: []);
   test('var', returns: [OBJECT, NULL], creates: []);
   test('A', returns: ['A'], creates: ['A']);
   test('A|B', returns: ['A', 'B'], creates: ['A', 'B']);
   test('A|B|C', returns: ['A', 'B', 'C'], creates: ['A', 'B', 'C']);
 
@@ skipping 13 matching lines @@
 
   test('returns:void;creates:A;', returns: [], creates: ['A']);
   test('returns:;creates:A|B;', returns: [OBJECT, NULL], creates: ['A', 'B']);
   test('returns:var;creates:A|B|C;',
       returns: [OBJECT, NULL], creates: ['A', 'B', 'C']);
   test('returns:A; creates:A|B|C; ', returns: ['A'], creates: ['A', 'B', 'C']);
   test(' returns:A|B;  creates:A|C;',
       returns: ['A', 'B'], creates: ['A', 'C']);
   test(' returns:A|B|C;   creates:A;  ',
       returns: ['A', 'B', 'C'], creates: ['A']);
+
+  testWithSideEffects('returns:void;', returns: [], creates: []);
+  testWithSideEffects('returns:void;', returns: [], creates: []);
+  testWithSideEffects('returns:;', returns: [OBJECT, NULL], creates: []);
+  testWithSideEffects('returns:var;', returns: [OBJECT, NULL], creates: []);
+  testWithSideEffects('returns:A;', returns: ['A'], creates: []);
+  testWithSideEffects('returns:A|B;', returns: ['A', 'B'], creates: []);
+  testWithSideEffects('returns:A|B|C;', returns: ['A', 'B', 'C'], creates: []);
+
+  testWithSideEffects('creates:void;', expectError: true);
+  testWithSideEffects('creates:;', expectError: true);
+  testWithSideEffects('creates:var;', expectError: true);
+  testWithSideEffects('creates:A;', returns: [], creates: ['A']);
+  testWithSideEffects('creates:A|B;', returns: [], creates: ['A', 'B']);
+  testWithSideEffects('creates:A|B|C;', returns: [], creates: ['A', 'B', 'C']);
+
+  testWithSideEffects('returns:void;creates:A;', returns: [], creates: ['A']);
+  testWithSideEffects('returns:;creates:A|B;',
+      returns: [OBJECT, NULL], creates: ['A', 'B']);
+  testWithSideEffects('returns:var;creates:A|B|C;',
+      returns: [OBJECT, NULL], creates: ['A', 'B', 'C']);
+  testWithSideEffects('returns:A; creates:A|B|C; ',
+      returns: ['A'], creates: ['A', 'B', 'C']);
+  testWithSideEffects(' returns:A|B;  creates:A|C;',
+      returns: ['A', 'B'], creates: ['A', 'C']);
+  testWithSideEffects(' returns:A|B|C;   creates:A;  ',
+      returns: ['A', 'B', 'C'], creates: ['A']);
 }