Change simpleName of anonymous mixin applications.

dart/tests/lib/mirrors/mixin_test.dart

 // Copyright (c) 2013, 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 test.mixin_test;
 
 import 'dart:mirrors';
 
 import 'package:expect/expect.dart';
 
@@ skipping 43 matching lines @@
   Expect.equals(a, b);
   expect(stringify(a), b);
   expect(stringify(b), a);
 }
 
 testMixin() {
   checkClass(Mixin, [
       'Class(s(Mixin) in s(test.mixin_test), top-level)',
       'Class(s(Object) in s(dart.core), top-level)',
   ]);
+

[ahe, 2013/09/03 22:42:27]

Ryan's whitespace changes made it hard for me to merge mixin_dart2js_test back
into this test. So I undid them.

   expect(
       '{i: Variable(s(i) in s(Mixin)),'
       ' m: Method(s(m) in s(Mixin))}',
       reflectClass(Mixin).members);
-  expect(
-      '{Mixin: Method(s(Mixin) in s(Mixin), constructor)}',
-      reflectClass(Mixin).constructors);
+
+  expect('{Mixin: Method(s(Mixin) in s(Mixin), constructor)}',
+         reflectClass(Mixin).constructors);
 }
 
 testMixin2() {
   checkClass(Mixin2, [
       'Class(s(Mixin2) in s(test.mixin_test), top-level)',
       'Class(s(Object) in s(dart.core), top-level)',
   ]);
+
   expect(
       '{i2: Variable(s(i2) in s(Mixin2)),'
       ' m2: Method(s(m2) in s(Mixin2))}',
       reflectClass(Mixin2).members);
-  expect(
-      '{Mixin2: Method(s(Mixin2) in s(Mixin2), constructor)}',
-      reflectClass(Mixin2).constructors);
+
+  expect('{Mixin2: Method(s(Mixin2) in s(Mixin2), constructor)}',
+         reflectClass(Mixin2).constructors);
 }
 
 testMixinApplication() {
   checkClass(MixinApplication, [
       'Class(s(MixinApplication) in s(test.mixin_test), top-level)',
       'Class(s(C) in s(test.model), top-level)',
       'Class(s(B) in s(test.model), top-level)',
       'Class(s(A) in s(test.model), top-level)',
       'Class(s(Object) in s(dart.core), top-level)',
   ]);
 
+  String owner = 'Mixin';
+  owner = 'MixinApplication'; /// 01: ok

[ngeoffray, 2013/09/04 06:59:21]

Does that mean the base file is a negative test?

[ahe, 2013/09/04 10:17:07]

Not exactly. It means that you have two positive tests. However, not both of
them can actually pass on the same implementation. 

So this is an alternative to having two files that can start diverging between
dart2js and the VM.

In this case, I think it more clearly demonstrates that the VM and dart2js
disagree on who is the owner of an anonymous mixin application. This wasn't
obvious before. See line113 for an example. 

[ngeoffray, 2013/09/04 10:23:50]

OK, could you please add a top-level comment on this test that explains what you
just described? Thanks!

[ahe, 2013/09/04 13:31:40]

Done.

   expect(
-      '{i: Variable(s(i) in s(Mixin)),'
-      ' m: Method(s(m) in s(Mixin))}',
+      '{i: Variable(s(i) in s($owner)),'
+      ' m: Method(s(m) in s($owner))}',
       reflectClass(MixinApplication).members);
-  expect(
-      '{MixinApplication: Method(s(MixinApplication) in s(MixinApplication),'
-      ' constructor)}',
-      reflectClass(MixinApplication).constructors);
+
+  expect('{MixinApplication: Method(s(MixinApplication) in s(MixinApplication),'
+         ' constructor)}',
+         reflectClass(MixinApplication).constructors);
 
   expectSame(reflectClass(C), reflectClass(MixinApplication).superclass);
 }
 
 testMixinApplicationA() {
+  // TODO(ahe): I don't think an anonymous mixin has an owner.
+  String owner = ' in s(test.mixin_test)';
+  owner = ''; /// 01: ok
   checkClass(MixinApplicationA, [
       'Class(s(MixinApplicationA) in s(test.mixin_test), top-level)',
-      'Class(s(test.model.C with test.mixin_test.Mixin) in s(test.mixin_test),'
-      ' top-level)',
+      'Class(s(test.model.C with test.mixin_test.Mixin)$owner, top-level)',
       'Class(s(C) in s(test.model), top-level)',
       'Class(s(B) in s(test.model), top-level)',
       'Class(s(A) in s(test.model), top-level)',
       'Class(s(Object) in s(dart.core), top-level)',
   ]);
 
+  owner = 'Mixin2';
+  owner = 'MixinApplicationA'; /// 01: ok
   expect(
-      '{i2: Variable(s(i2) in s(Mixin2)),'
-      ' m2: Method(s(m2) in s(Mixin2))}',
+      '{i2: Variable(s(i2) in s($owner)),'
+      ' m2: Method(s(m2) in s($owner))}',
       reflectClass(MixinApplicationA).members);
+
   expect(
       '{MixinApplicationA: Method(s(MixinApplicationA) in s(MixinApplicationA),'
       ' constructor)}',
       reflectClass(MixinApplicationA).constructors);
 
   expect(
       '{i: Variable(s(i) in s(Mixin)),'
       ' m: Method(s(m) in s(Mixin))}',
       reflectClass(MixinApplicationA).superclass.members);
+
+  String name = 'test.model.C with test.mixin_test.Mixin';
+  name = 'Mixin'; /// 01: ok
   expect(
-      '{test.model.C with test.mixin_test.Mixin:'
-      ' Method(s(test.model.C with test.mixin_test.Mixin)'
-      ' in s(test.model.C with test.mixin_test.Mixin), constructor)}',
+      '{$name:'
+      ' Method(s($name)'
+      ' in s($name), constructor)}',
       reflectClass(MixinApplicationA).superclass.constructors);
 
   expectSame(
       reflectClass(C),
       reflectClass(MixinApplicationA).superclass.superclass);
 }
 
 testUnusedMixinApplication() {
   checkClass(UnusedMixinApplication, [
       'Class(s(UnusedMixinApplication) in s(test.mixin_test), top-level)',
       'Class(s(C) in s(test.model), top-level)',
       'Class(s(B) in s(test.model), top-level)',
       'Class(s(A) in s(test.model), top-level)',
       'Class(s(Object) in s(dart.core), top-level)',
   ]);
 
+  String owner = 'Mixin';
+  owner = 'UnusedMixinApplication'; /// 01: ok
   expect(
-      '{i: Variable(s(i) in s(Mixin)),'
-      ' m: Method(s(m) in s(Mixin))}',
+      '{i: Variable(s(i) in s($owner)),'
+      ' m: Method(s(m) in s($owner))}',
       reflectClass(UnusedMixinApplication).members);
+
   expect(
       '{UnusedMixinApplication: Method(s(UnusedMixinApplication)'
       ' in s(UnusedMixinApplication), constructor)}',
       reflectClass(UnusedMixinApplication).constructors);
 
   expectSame(reflectClass(C), reflectClass(UnusedMixinApplication).superclass);
 }
 
 testSubclass() {
+  String owner = ' in s(test.mixin_test)';
+  owner = ''; /// 01: ok
   checkClass(Subclass, [
       'Class(s(Subclass) in s(test.mixin_test), top-level)',
-      'Class(s(test.model.C with test.mixin_test.Mixin) in s(test.mixin_test),'
-      ' top-level)',
+      'Class(s(test.model.C with test.mixin_test.Mixin)$owner, top-level)',
       'Class(s(C) in s(test.model), top-level)',
       'Class(s(B) in s(test.model), top-level)',
       'Class(s(A) in s(test.model), top-level)',
       'Class(s(Object) in s(dart.core), top-level)',
   ]);
 
   expect(
       '{f: Method(s(f) in s(Subclass))}',
       reflectClass(Subclass).members);
+
   expect(
       '{Subclass: Method(s(Subclass) in s(Subclass), constructor)}',
       reflectClass(Subclass).constructors);
 
   expect(
       '{i: Variable(s(i) in s(Mixin)),'
       ' m: Method(s(m) in s(Mixin))}',
       reflectClass(Subclass).superclass.members);
+
+  String name = 'test.model.C with test.mixin_test.Mixin';
+  name = 'Mixin'; /// 01: ok
   expect(
-      '{test.model.C with test.mixin_test.Mixin:'
-      ' Method(s(test.model.C with test.mixin_test.Mixin)'
-      ' in s(test.model.C with test.mixin_test.Mixin), constructor)}',
+      '{$name:'
+      ' Method(s($name)'
+      ' in s($name), constructor)}',
       reflectClass(Subclass).superclass.constructors);
 
   expectSame(
       reflectClass(C),
       reflectClass(Subclass).superclass.superclass);
 }
 
 testSubclass2() {
   checkClass(Subclass2, [
       'Class(s(Subclass2) in s(test.mixin_test), top-level)',
       'Class(s(MixinApplication) in s(test.mixin_test), top-level)',
       'Class(s(C) in s(test.model), top-level)',
       'Class(s(B) in s(test.model), top-level)',
       'Class(s(A) in s(test.model), top-level)',
       'Class(s(Object) in s(dart.core), top-level)',
   ]);
 
   expect(
       '{g: Method(s(g) in s(Subclass2))}',
       reflectClass(Subclass2).members);
+
   expect(
       '{Subclass2: Method(s(Subclass2) in s(Subclass2), constructor)}',
       reflectClass(Subclass2).constructors);
 
   expectSame(
       reflectClass(MixinApplication),
       reflectClass(Subclass2).superclass);
 }
 
 testSubclassA() {
+  // TODO(ahe): I don't think an anonymous mixin has an owner.
+  String owner = ' in s(test.mixin_test)';
+  owner = ''; /// 01: ok
   checkClass(SubclassA, [
       'Class(s(SubclassA) in s(test.mixin_test), top-level)',
       'Class(s(test.model.C with test.mixin_test.Mixin, test.mixin_test.Mixin2)'
-      ' in s(test.mixin_test), top-level)',
-      'Class(s(test.model.C with test.mixin_test.Mixin) in s(test.mixin_test),'
-      ' top-level)',
+      '$owner, top-level)',
+      'Class(s(test.model.C with test.mixin_test.Mixin)$owner, top-level)',
       'Class(s(C) in s(test.model), top-level)',
       'Class(s(B) in s(test.model), top-level)',
       'Class(s(A) in s(test.model), top-level)',
       'Class(s(Object) in s(dart.core), top-level)',
   ]);
 
   expect(
       '{fa: Method(s(fa) in s(SubclassA))}',
       reflectClass(SubclassA).members);
+
   expect(
       '{SubclassA: Method(s(SubclassA) in s(SubclassA), constructor)}',
       reflectClass(SubclassA).constructors);
 
   expect(
       '{i2: Variable(s(i2) in s(Mixin2)),'
       ' m2: Method(s(m2) in s(Mixin2))}',
       reflectClass(SubclassA).superclass.members);
+
+  String name =
+      'test.model.C with test.mixin_test.Mixin, test.mixin_test.Mixin2';
+  name = 'Mixin2'; /// 01: ok
   expect(
-      '{test.model.C with test.mixin_test.Mixin, test.mixin_test.Mixin2:'
-      ' Method(s(test.model.C with test.mixin_test.Mixin,'
-      ' test.mixin_test.Mixin2) in s(test.model.C with test.mixin_test.Mixin,'
-      ' test.mixin_test.Mixin2), constructor)}',
+      '{$name: Method(s($name) in s($name), constructor)}',
       reflectClass(SubclassA).superclass.constructors);
 
   expect(
       '{i: Variable(s(i) in s(Mixin)),'
       ' m: Method(s(m) in s(Mixin))}',
       reflectClass(SubclassA).superclass.superclass.members);
+
+  name = 'test.model.C with test.mixin_test.Mixin';
+  name = 'Mixin'; /// 01: ok
   expect(
-      '{test.model.C with test.mixin_test.Mixin:'
-      ' Method(s(test.model.C with test.mixin_test.Mixin)'
-      ' in s(test.model.C with test.mixin_test.Mixin), constructor)}',
+      '{$name:'
+      ' Method(s($name)'
+      ' in s($name), constructor)}',
       reflectClass(SubclassA).superclass.superclass.constructors);
 
   expectSame(
       reflectClass(C),
       reflectClass(SubclassA).superclass.superclass.superclass);
 }
 
 testSubclass2A() {
+  // TODO(ahe): I don't think an anonymous mixin has an owner.
+  String owner = ' in s(test.mixin_test)';
+  owner = ''; /// 01: ok
   checkClass(Subclass2A, [
       'Class(s(Subclass2A) in s(test.mixin_test), top-level)',
       'Class(s(MixinApplicationA) in s(test.mixin_test), top-level)',
-      'Class(s(test.model.C with test.mixin_test.Mixin) in s(test.mixin_test),'
+      'Class(s(test.model.C with test.mixin_test.Mixin)$owner,'
       ' top-level)',
       'Class(s(C) in s(test.model), top-level)',
       'Class(s(B) in s(test.model), top-level)',
       'Class(s(A) in s(test.model), top-level)',
       'Class(s(Object) in s(dart.core), top-level)',
   ]);
 
   expect(
       '{ga: Method(s(ga) in s(Subclass2A))}',
       reflectClass(Subclass2A).members);
+
   expect(
       '{Subclass2A: Method(s(Subclass2A) in s(Subclass2A), constructor)}',
       reflectClass(Subclass2A).constructors);
 
   expectSame(reflectClass(MixinApplicationA),
              reflectClass(Subclass2A).superclass);
 }
 
 main() {
   testMixin();
   testMixin2();
   testMixinApplication();
   testMixinApplicationA();
   testUnusedMixinApplication();
   testSubclass();
   testSubclass2();
   testSubclassA();
   testSubclass2A();
 }