blob: 4ab6a0002e670ae2915fd3f3acaa3dea9d150a2d [file] [log] [blame]
// Copyright (c) 2011, 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.
// @dart = 2.9
import "package:expect/expect.dart";
class A {
A() {
NamingTest.count++;
}
foo(a, b) {
Expect.equals(1, a);
Expect.equals(2, b);
}
}
class MyException {
MyException() {}
}
class debugger {
static const int __PROTO__ = 5;
int x;
factory debugger.F() {
return new debugger(1);
}
debugger(x) : this.x = x + 1 {}
debugger.C(x) : this.x = x + 2 {}
debugger.C$C(x) : this.x = x + 3 {}
debugger.C$I(x) : this.x = x + 4 {}
}
class debugger$C {
int x;
factory debugger$C.F() {
return new debugger$C(1);
}
debugger$C(x) : this.x = x + 5 {}
debugger$C.C(x) : this.x = x + 6 {}
debugger$C.C$C(x) : this.x = x + 7 {}
debugger$C.C$I(x) : this.x = x + 8 {}
}
class debugger$C$C {
int x;
factory debugger$C$C.F() {
return new debugger$C$C(1);
}
debugger$C$C(x) : this.x = x + 9 {}
debugger$C$C.C(x) : this.x = x + 10 {}
debugger$C$C.C$C(x) : this.x = x + 11 {}
debugger$C$C.C$I(x) : this.x = x + 12 {}
}
class with$I extends debugger$C {
int y;
factory with$I.F() {
return new with$I(1, 2);
}
with$I(x, y)
: this.y = y + 11,
super(x) {}
with$I.I(x, y)
: this.y = y + 12,
super.C(x) {}
with$I.C(x, y)
: this.y = y + 13,
super.C$C(x){}
with$I.I$C(x, y)
: this.y = y + 14,
super.C$I(x) {}
with$I.C$C(x, y)
: this.y = y + 15,
super(x) {}
with$I.C$C$C(x, y)
: this.y = y + 16,
super.C(x) {}
with$I.$C$I(x, y)
:this.y = y + 17,
super.C$C(x) {}
with$I.$$I$C(x, y)
:this.y = y + 18,
super.C$I(x) {}
with$I.$(x, y)
: this.y = y + 19,
super(x) {}
with$I.$$(x, y)
: this.y = y + 20,
super.C(x) {}
}
class with$C extends debugger$C$C {
int y;
factory with$C.F() {
return new with$C(1, 2);
}
with$C(x, y)
: this.y = y + 21,
super(x) {}
with$C.I(x, y)
: this.y = y + 22,
super.C(x) {}
with$C.C(x, y)
: this.y = y + 23,
super.C$C(x) {}
with$C.I$C(x, y)
: this.y = y + 24,
super.C$I(x) {}
with$C.C$C(x, y)
: this.y = y + 25,
super(x) {}
with$C.C$C$C(x, y)
: this.y = y + 26,
super.C(x) {}
with$C.$C$I(x, y)
: this.y = y + 27,
super.C$C(x) {}
with$C.$$I$C(x, y)
: this.y = y + 28,
super.C$I(x) {}
with$C.$(x, y)
: this.y = y + 29,
super(x) {}
with$C.$$(x, y)
: this.y = y + 30,
super.C(x) {}
}
class with$I$C extends debugger$C$C {
int y;
factory with$I$C.F() {
return new with$I$C(1, 2);
}
with$I$C(x, y)
: this.y = y + 31,
super(x) {}
with$I$C.I(x, y)
: this.y = y + 32,
super.C(x) {}
with$I$C.C(x, y)
: this.y = y + 33,
super.C$C(x) {}
with$I$C.I$C(x, y)
: this.y = y + 34,
super.C$I(x) {}
with$I$C.C$C(x, y)
: this.y = y + 35,
super(x) {}
with$I$C.C$C$C(x, y)
: this.y = y + 36,
super.C(x) {}
with$I$C.$C$I(x, y)
: this.y = y + 37,
super.C$C(x) {}
with$I$C.$$I$C(x, y)
: this.y = y + 38,
super.C$I(x) {}
with$I$C.$(x, y)
: this.y = y + 39,
super(x) {}
with$I$C.$$(x, y)
: this.y = y + 40,
super.C(x) {}
}
class Tata {
var prototype;
Tata() : this.prototype = 0 {}
__PROTO__$() {
return 12;
}
}
class Toto extends Tata {
var __PROTO__;
Toto()
: this.__PROTO__ = 0,
super() {}
prototype$() {
return 10;
}
titi() {
Expect.equals(0, prototype);
Expect.equals(0, __PROTO__);
prototype = 3;
__PROTO__ = 5;
Expect.equals(3, prototype);
Expect.equals(5, __PROTO__);
Expect.equals(10, prototype$());
Expect.equals(12, __PROTO__$());
Expect.equals(12, this.__PROTO__$());
Expect.equals(10, this.prototype$());
Expect.equals(12, __PROTO__$());
}
}
class Bug4082360 {
int x_;
Bug4082360() {}
int get x {
return x_;
}
void set x(int value) {
x_ = value;
}
void indirectSet(int value) {
x = value;
}
static void test() {
var bug = new Bug4082360();
bug.indirectSet(42);
Expect.equals(42, bug.x_);
Expect.equals(42, bug.x);
}
}
class Hoisting {
var f_;
Hoisting.negate(var x) {
f_ = () {
return x;
};
}
operator -() {
var x = 3;
return () {
return x + 1;
};
}
operator [](x) {
return () {
return x + 3;
};
}
static void test() {
var h = new Hoisting.negate(1);
Expect.equals(1, (h.f_)());
var f = -h;
Expect.equals(4, f());
Expect.equals(7, h[4]());
}
}
// It is not possible to make sure that the backend uses the hardcoded names
// we are testing against. This test might therefore become rapidly out of date
class NamingTest {
static int count;
static testExceptionNaming() {
// Exceptions use a hardcoded "e" as exception name. If the namer works
// correctly then it will be renamed in case of clashes.
var e = 3;
var caught = 0;
try {
throw new MyException();
} catch (exc) {
try {
throw new MyException();
} catch (exc2) {
caught++;
}
Expect.equals(1, caught);
caught++;
}
Expect.equals(2, caught);
Expect.equals(3, e);
}
static testTmpNaming() {
Expect.equals(0, count);
var tmp$0 = 1;
var tmp$1 = 2;
new A().foo(tmp$0, tmp$1++);
Expect.equals(1, count);
Expect.equals(3, tmp$1);
}
static testScopeNaming() {
// Alias scopes use a hardcoded "dartc_scp$<depth>" as names.
var dartc_scp$1 = 5;
var foo = 8;
var f = () {
var dartc_scp$1 = 15;
return foo + dartc_scp$1;
};
Expect.equals(5, dartc_scp$1);
Expect.equals(23, f());
}
static testGlobalMangling() {
var x;
x = new debugger(0);
Expect.equals(1, x.x);
x = new debugger.C(0);
Expect.equals(2, x.x);
x = new debugger.C$C(0);
Expect.equals(3, x.x);
x = new debugger.C$I(0);
Expect.equals(4, x.x);
x = new debugger$C(0);
Expect.equals(5, x.x);
x = new debugger$C.C(0);
Expect.equals(6, x.x);
x = new debugger$C.C$C(0);
Expect.equals(7, x.x);
x = new debugger$C.C$I(0);
Expect.equals(8, x.x);
x = new debugger$C$C(0);
Expect.equals(9, x.x);
x = new debugger$C$C.C(0);
Expect.equals(10, x.x);
x = new debugger$C$C.C$C(0);
Expect.equals(11, x.x);
x = new debugger$C$C.C$I(0);
Expect.equals(12, x.x);
x = new with$I(0, 0);
Expect.equals(5, x.x);
Expect.equals(11, x.y);
x = new with$I.I(0, 0);
Expect.equals(6, x.x);
Expect.equals(12, x.y);
x = new with$I.C(0, 0);
Expect.equals(7, x.x);
Expect.equals(13, x.y);
x = new with$I.I$C(0, 0);
Expect.equals(8, x.x);
Expect.equals(14, x.y);
x = new with$I.C$C(0, 0);
Expect.equals(5, x.x);
Expect.equals(15, x.y);
x = new with$I.C$C$C(0, 0);
Expect.equals(6, x.x);
Expect.equals(16, x.y);
x = new with$I.$C$I(0, 0);
Expect.equals(7, x.x);
Expect.equals(17, x.y);
x = new with$I.$$I$C(0, 0);
Expect.equals(8, x.x);
Expect.equals(18, x.y);
x = new with$I.$(0, 0);
Expect.equals(5, x.x);
Expect.equals(19, x.y);
x = new with$I.$$(0, 0);
Expect.equals(6, x.x);
Expect.equals(20, x.y);
x = new with$C(0, 0);
Expect.equals(9, x.x);
Expect.equals(21, x.y);
x = new with$C.I(0, 0);
Expect.equals(10, x.x);
Expect.equals(22, x.y);
x = new with$C.C(0, 0);
Expect.equals(11, x.x);
Expect.equals(23, x.y);
x = new with$C.I$C(0, 0);
Expect.equals(12, x.x);
Expect.equals(24, x.y);
x = new with$C.C$C(0, 0);
Expect.equals(9, x.x);
Expect.equals(25, x.y);
x = new with$C.C$C$C(0, 0);
Expect.equals(10, x.x);
Expect.equals(26, x.y);
x = new with$C.$C$I(0, 0);
Expect.equals(11, x.x);
Expect.equals(27, x.y);
x = new with$C.$$I$C(0, 0);
Expect.equals(12, x.x);
Expect.equals(28, x.y);
x = new with$C.$(0, 0);
Expect.equals(9, x.x);
Expect.equals(29, x.y);
x = new with$C.$$(0, 0);
Expect.equals(10, x.x);
Expect.equals(30, x.y);
x = new with$I$C(0, 0);
Expect.equals(9, x.x);
Expect.equals(31, x.y);
x = new with$I$C.I(0, 0);
Expect.equals(10, x.x);
Expect.equals(32, x.y);
x = new with$I$C.C(0, 0);
Expect.equals(11, x.x);
Expect.equals(33, x.y);
x = new with$I$C.I$C(0, 0);
Expect.equals(12, x.x);
Expect.equals(34, x.y);
x = new with$I$C.C$C(0, 0);
Expect.equals(9, x.x);
Expect.equals(35, x.y);
x = new with$I$C.C$C$C(0, 0);
Expect.equals(10, x.x);
Expect.equals(36, x.y);
x = new with$I$C.$C$I(0, 0);
Expect.equals(11, x.x);
Expect.equals(37, x.y);
x = new with$I$C.$$I$C(0, 0);
Expect.equals(12, x.x);
Expect.equals(38, x.y);
x = new with$I$C.$(0, 0);
Expect.equals(9, x.x);
Expect.equals(39, x.y);
x = new with$I$C.$$(0, 0);
Expect.equals(10, x.x);
Expect.equals(40, x.y);
}
static void testMemberMangling() {
Expect.equals(5, debugger.__PROTO__);
new Toto().titi();
}
static void testFactoryMangling() {
var o = new debugger.F() as dynamic;
Expect.equals(2, o.x);
o = new debugger$C.F();
Expect.equals(6, o.x);
o = new debugger$C$C.F();
Expect.equals(10, o.x);
o = new with$I.F();
Expect.equals(6, o.x);
Expect.equals(13, o.y);
o = new with$C.F();
Expect.equals(10, o.x);
Expect.equals(23, o.y);
o = new with$I$C.F();
Expect.equals(10, o.x);
Expect.equals(33, o.y);
}
static testFunctionParameters() {
a(eval) {
return eval;
}
b(arguments) {
return arguments;
}
Expect.equals(10, a(10));
Expect.equals(10, b(10));
}
static testPseudoTokens() {
var EOS = 400;
var ILLEGAL = 99;
Expect.equals(499, EOS + ILLEGAL);
}
static testDollar() {
Expect.equals(123, $(123).wrapped);
var x = new Object(), y = new Object();
Expect.identical(x, $(x).wrapped);
Expect.identical(y, $(x).$add(y));
Expect.identical(x, $(x).$negate());
Expect.equals(123, $(x) + x);
Expect.equals(444, -$(x));
}
static void testMain() {
count = 0;
testExceptionNaming();
testTmpNaming();
testScopeNaming();
testGlobalMangling();
testMemberMangling();
testFactoryMangling();
testFunctionParameters();
Bug4082360.test();
Hoisting.test();
testPseudoTokens();
testDollar();
}
}
// Test that the generated JS names don't conflict with "$"
class DartQuery {
Object wrapped;
DartQuery(this.wrapped);
$add(Object other) => other;
$negate() => wrapped;
operator +(Object other) => 123;
operator -() => 444;
}
$add(Object first, Object second) => second;
DartQuery $(Object obj) => new DartQuery(obj);
// Ensure we don't have false positive.
class Naming2Test {
Naming2Test() {}
int get foo {
return 1;
}
set foo(x) {}
static void main(args) {
var a = new Naming2Test() as dynamic;
Expect.throwsNoSuchMethodError(() => a.foo(2));
}
}
main() {
NamingTest.testMain();
Naming2Test.main(null);
}