Add tests

Author: ahejlsberg

tests/cases/compiler/mixinPrivateAndProtected.ts

@@ -0,0 +1,88 @@
+// Repro from #13830
+
+type Constructor<T> = new(...args: any[]) => T;
+
+class A {
+    public pb: number = 2;
+    protected ptd: number = 1;
+    private pvt: number = 0;
+}
+
+function mixB<T extends Constructor<{}>>(Cls: T) {
+    return class extends Cls {
+        protected ptd: number = 10;
+        private pvt: number = 0;
+    };
+}
+
+function mixB2<T extends Constructor<A>>(Cls: T) {
+    return class extends Cls {
+        protected ptd: number = 10;
+    };
+}
+
+const
+    AB = mixB(A),
+    AB2 = mixB2(A);
+
+function mixC<T extends Constructor<{}>>(Cls: T) {
+    return class extends Cls {
+        protected ptd: number = 100;
+        private pvt: number = 0;
+    };
+}
+
+const
+    AB2C = mixC(AB2),
+    ABC = mixC(AB);
+
+const
+    a = new A(),
+    ab = new AB(),
+    abc = new ABC(),
+    ab2c = new AB2C();
+
+a.pb.toFixed();
+a.ptd.toFixed();    // Error
+a.pvt.toFixed();    // Error
+
+ab.pb.toFixed();
+ab.ptd.toFixed();   // Error
+ab.pvt.toFixed();   // Error
+
+abc.pb.toFixed();
+abc.ptd.toFixed();  // Error
+abc.pvt.toFixed();  // Error
+
+ab2c.pb.toFixed();
+ab2c.ptd.toFixed(); // Error
+ab2c.pvt.toFixed(); // Error
+
+// Repro from #13924
+
+class Person {
+	constructor(public name: string) {}
+
+	protected myProtectedFunction() {
+		// do something
+	}
+}
+
+function PersonMixin<T extends Constructor<Person>>(Base: T) {
+	return class extends Base {
+		constructor(...args: any[]) {
+			super(...args);
+		}
+
+		myProtectedFunction() {
+			super.myProtectedFunction();
+			// do more things
+		}
+	};
+}
+
+class Customer extends PersonMixin(Person) {
+	accountBalance: number;
+    f() {
+    }
+}

tests/cases/conformance/classes/mixinAccessModifiers.ts

@@ -0,0 +1,108 @@
+// @declaration: true
+
+type Constructable = new (...args: any[]) => object;
+
+class Private {
+	constructor (...args: any[]) {}
+	private p: string;
+}
+
+class Private2 {
+	constructor (...args: any[]) {}
+	private p: string;
+}
+
+class Protected {
+	constructor (...args: any[]) {}
+	protected p: string;
+	protected static s: string;
+}
+
+class Protected2 {
+	constructor (...args: any[]) {}
+	protected p: string;
+	protected static s: string;
+}
+
+class Public {
+	constructor (...args: any[]) {}
+	public p: string;
+	public static s: string;
+}
+
+class Public2 {
+	constructor (...args: any[]) {}
+	public p: string;
+	public static s: string;
+}
+
+function f1(x: Private & Private2) {
+	x.p;  // Error, private constituent makes property inaccessible
+}
+
+function f2(x: Private & Protected) {
+	x.p;  // Error, private constituent makes property inaccessible
+}
+
+function f3(x: Private & Public) {
+	x.p;  // Error, private constituent makes property inaccessible
+}
+
+function f4(x: Protected & Protected2) {
+	x.p;  // Error, protected when all constituents are protected
+}
+
+function f5(x: Protected & Public) {
+	x.p;  // Ok, public if any constituent is public
+}
+
+function f6(x: Public & Public2) {
+	x.p;  // Ok, public if any constituent is public
+}
+
+declare function Mix<T, U>(c1: T, c2: U): T & U;
+
+// Can't derive from type with inaccessible properties
+
+class C1 extends Mix(Private, Private2) {}
+class C2 extends Mix(Private, Protected) {}
+class C3 extends Mix(Private, Public) {}
+
+class C4 extends Mix(Protected, Protected2) {
+	f(c4: C4, c5: C5, c6: C6) {
+		c4.p;
+		c5.p;
+		c6.p;
+	}
+	static g() {
+		C4.s;
+		C5.s;
+		C6.s
+	}
+}
+
+class C5 extends Mix(Protected, Public) {
+	f(c4: C4, c5: C5, c6: C6) {
+		c4.p;  // Error, not in class deriving from Protected2
+		c5.p;
+		c6.p;
+	}
+	static g() {
+		C4.s;  // Error, not in class deriving from Protected2
+		C5.s;
+		C6.s
+	}
+}
+
+class C6 extends Mix(Public, Public2) {
+	f(c4: C4, c5: C5, c6: C6) {
+		c4.p;  // Error, not in class deriving from Protected2
+		c5.p;
+		c6.p;
+	}
+	static g() {
+		C4.s;  // Error, not in class deriving from Protected2
+		C5.s;
+		C6.s
+	}
+}