| /third_party/typescript/tests/baselines/reference/ |
| D | thisTypeAccessibility.types | 2 class MyClass {
3 >MyClass : MyClass
30 interface MyClass {
66 MyClass.prototype.extension1 = function (this: MyClass, p: number) {
67 …MyClass.prototype.extension1 = function (this: MyClass, p: number) { this.p = p; this.pp = …
68 >MyClass.prototype.extension1 : (p: number) => void
69 >MyClass.prototype : MyClass
70 >MyClass : typeof MyClass
71 >prototype : MyClass
73 …: MyClass, p: number) { this.p = p; this.pp = p; this.ppp = p; MyClass.sp = p; MyC…
[all …]
|
| D | thisTypeAccessibility.symbols | 2 class MyClass {
3 >MyClass : Symbol(MyClass, Decl(thisTypeAccessibility.ts, 0, 0), Decl(thisTypeAccessibility.ts, 7, …
6 >p : Symbol(MyClass.p, Decl(thisTypeAccessibility.ts, 0, 15))
9 >pp : Symbol(MyClass.pp, Decl(thisTypeAccessibility.ts, 1, 28))
12 >ppp : Symbol(MyClass.ppp, Decl(thisTypeAccessibility.ts, 2, 31))
15 >sp : Symbol(MyClass.sp, Decl(thisTypeAccessibility.ts, 3, 29))
18 >spp : Symbol(MyClass.spp, Decl(thisTypeAccessibility.ts, 4, 36))
21 >sppp : Symbol(MyClass.sppp, Decl(thisTypeAccessibility.ts, 5, 39))
24 interface MyClass {
25 >MyClass : Symbol(MyClass, Decl(thisTypeAccessibility.ts, 0, 0), Decl(thisTypeAccessibility.ts, 7, …
[all …]
|
| D | thisTypeAccessibility.js | 2 class MyClass { class
11 interface MyClass {
26 MyClass.prototype.extension1 = function (this: MyClass, p: number) { argument
30 MyClass.sp = p;
31 MyClass.spp = p;
32 MyClass.sppp = p;
35 MyClass.prototype.extension2 = function<T extends MyClass> (this: T, p: number) {
39 MyClass.sp = p;
40 MyClass.spp = p;
41 MyClass.sppp = p;
[all …]
|
| D | jsDeclarationsFunctionPrototypeStatic.types | 2 module.exports = MyClass;
3 >module.exports = MyClass : typeof MyClass
4 >module.exports : typeof MyClass
5 >module : { exports: typeof MyClass; }
6 >exports : typeof MyClass
7 >MyClass : typeof MyClass
9 function MyClass() {}
10 >MyClass : typeof MyClass
12 MyClass.staticMethod = function() {}
13 >MyClass.staticMethod = function() {} : () => void
[all …]
|
| D | signaturesUseJSDocForOptionalParameters.types | 2 function MyClass() {
3 >MyClass : typeof MyClass
15 * @returns {MyClass}
17 MyClass.prototype.optionalParam = function(required, notRequired) {
18 >MyClass.prototype.optionalParam = function(required, notRequired) { return this;} : (required: …
19 >MyClass.prototype.optionalParam : any
20 >MyClass.prototype : any
21 >MyClass : typeof MyClass
24 …ion(required, notRequired) { return this;} : (required: string, notRequired?: string) => MyClass
32 let pInst = new MyClass();
[all …]
|
| D | moduleResolutionWithSymlinks_withOutDir.types | 2 import { MyClass } from "./library-a";
3 >MyClass : typeof MyClass
6 >MyClass2 : typeof MyClass
8 let x: MyClass;
9 >x : MyClass
12 >y : MyClass
15 >x = y : MyClass
16 >x : MyClass
17 >y : MyClass
20 >y = x : MyClass
[all …]
|
| D | moduleResolutionWithSymlinks.types | 2 import { MyClass } from "./library-a";
3 >MyClass : typeof MyClass
6 >MyClass2 : typeof MyClass
8 let x: MyClass;
9 >x : MyClass
12 >y : MyClass
15 >x = y : MyClass
16 >x : MyClass
17 >y : MyClass
20 >y = x : MyClass
[all …]
|
| D | jsDeclarationsFunctionPrototypeStatic.symbols | 2 module.exports = MyClass;
6 >MyClass : Symbol(MyClass, Decl(source.js, 0, 25), Decl(source.js, 2, 21), Decl(source.js, 4, 40))
8 function MyClass() {}
9 >MyClass : Symbol(MyClass, Decl(source.js, 0, 25), Decl(source.js, 2, 21), Decl(source.js, 4, 40))
11 MyClass.staticMethod = function() {}
12 >MyClass.staticMethod : Symbol(MyClass.staticMethod, Decl(source.js, 2, 21))
13 >MyClass : Symbol(MyClass, Decl(source.js, 0, 25), Decl(source.js, 2, 21), Decl(source.js, 4, 40))
14 >staticMethod : Symbol(MyClass.staticMethod, Decl(source.js, 2, 21))
16 MyClass.prototype.method = function() {}
17 >MyClass.prototype : Symbol(MyClass.method, Decl(source.js, 3, 36))
[all …]
|
| D | signaturesUseJSDocForOptionalParameters.symbols | 2 function MyClass() {
3 >MyClass : Symbol(MyClass, Decl(jsDocOptionality.js, 0, 0))
6 >this.prop : Symbol(MyClass.prop, Decl(jsDocOptionality.js, 0, 20))
7 >this : Symbol(MyClass, Decl(jsDocOptionality.js, 0, 0))
8 >prop : Symbol(MyClass.prop, Decl(jsDocOptionality.js, 0, 20))
13 * @returns {MyClass}
15 MyClass.prototype.optionalParam = function(required, notRequired) {
16 >MyClass.prototype : Symbol(MyClass.optionalParam, Decl(jsDocOptionality.js, 2, 1))
17 >MyClass : Symbol(MyClass, Decl(jsDocOptionality.js, 0, 0))
19 >optionalParam : Symbol(MyClass.optionalParam, Decl(jsDocOptionality.js, 2, 1))
[all …]
|
| D | thisTypeAccessibility.errors.txt | 1 …bility.ts(26,10): error TS2341: Property 'p' is private and only accessible within class 'MyClass'.
2 …ility.ts(29,13): error TS2341: Property 'sp' is private and only accessible within class 'MyClass'.
3 …or TS2445: Property 'spp' is protected and only accessible within class 'MyClass' and its subclass…
4 …bility.ts(35,10): error TS2341: Property 'p' is private and only accessible within class 'MyClass'.
5 …ility.ts(38,13): error TS2341: Property 'sp' is private and only accessible within class 'MyClass'.
6 …or TS2445: Property 'spp' is protected and only accessible within class 'MyClass' and its subclass…
7 …bility.ts(44,10): error TS2341: Property 'p' is private and only accessible within class 'MyClass'.
8 …ility.ts(47,13): error TS2341: Property 'sp' is private and only accessible within class 'MyClass'.
9 …or TS2445: Property 'spp' is protected and only accessible within class 'MyClass' and its subclass…
16 class MyClass {
[all …]
|
| D | derivedTypeCallingBaseImplWithOptionalParams.types | 7 class MyClass implements MyInterface {
8 >MyClass : MyClass
16 var x: MyInterface = new MyClass();
18 >new MyClass() : MyClass
19 >MyClass : typeof MyClass
21 x.myMethod(); // should be valid, but MyClass has no implementation to handle it.
27 var y: MyClass = new MyClass();
28 >y : MyClass
29 >new MyClass() : MyClass
30 >MyClass : typeof MyClass
[all …]
|
| D | jsDeclarationsFunctionPrototypeStatic.js | 2 module.exports = MyClass;
4 function MyClass() {} class
5 MyClass.staticMethod = function() {}
6 MyClass.prototype.method = function() {}
7 MyClass.staticProperty = 123;
17 module.exports = MyClass;
18 function MyClass() { }
19 MyClass.staticMethod = function () { };
20 MyClass.prototype.method = function () { };
21 MyClass.staticProperty = 123;
[all …]
|
| D | jsDeclarationsExportAssignedConstructorFunction.symbols | 3 module.exports.MyClass = function() {
4 >module.exports.MyClass : Symbol(MyClass, Decl(jsDeclarationsExportAssignedConstructorFunction.js, …
5 >module.exports : Symbol(MyClass, Decl(jsDeclarationsExportAssignedConstructorFunction.js, 0, 0), D…
8 >MyClass : Symbol(MyClass, Decl(jsDeclarationsExportAssignedConstructorFunction.js, 0, 0), Decl(jsD…
11 >this.x : Symbol(MyClass.x, Decl(jsDeclarationsExportAssignedConstructorFunction.js, 1, 37))
12 >this : Symbol(MyClass, Decl(jsDeclarationsExportAssignedConstructorFunction.js, 1, 24))
13 >x : Symbol(MyClass.x, Decl(jsDeclarationsExportAssignedConstructorFunction.js, 1, 37))
15 module.exports.MyClass.prototype = {
16 >module.exports.MyClass.prototype : Symbol(MyClass.prototype, Decl(jsDeclarationsExportAssignedCons…
17 >module.exports.MyClass : Symbol(MyClass, Decl(jsDeclarationsExportAssignedConstructorFunction.js, …
[all …]
|
| D | moduleResolutionWithSymlinks.symbols | 2 import { MyClass } from "./library-a";
3 >MyClass : Symbol(MyClass, Decl(app.ts, 0, 8))
8 let x: MyClass;
10 >MyClass : Symbol(MyClass, Decl(app.ts, 0, 8))
29 echo 'export class MyClass { private x: number; }' > library-a/index.ts
32 echo 'import {MyClass} from "library-a"; export { MyClass as MyClass2 }' > index.ts
39 echo 'import { MyClass } from "./library-a"; import { MyClass2 } from "./library-b"; let x: MyClass…
47 export class MyClass { private x: number; }
48 >MyClass : Symbol(MyClass, Decl(index.ts, 0, 0))
49 >x : Symbol(MyClass.x, Decl(index.ts, 3, 22))
[all …]
|
| D | jsDeclarationsExportAssignedConstructorFunction.types | 3 module.exports.MyClass = function() {
4 >module.exports.MyClass = function() { this.x = 1} : typeof MyClass
5 >module.exports.MyClass : typeof MyClass
9 >MyClass : typeof MyClass
10 >function() { this.x = 1} : typeof MyClass
19 module.exports.MyClass.prototype = {
20 >module.exports.MyClass.prototype = { a: function() { }} : { a: () => void; }
21 >module.exports.MyClass.prototype : { a: () => void; }
22 >module.exports.MyClass : typeof MyClass
26 >MyClass : typeof MyClass
|
| D | moduleResolutionWithSymlinks_withOutDir.symbols | 2 import { MyClass } from "./library-a";
3 >MyClass : Symbol(MyClass, Decl(app.ts, 0, 8))
8 let x: MyClass;
10 >MyClass : Symbol(MyClass, Decl(app.ts, 0, 8))
27 export class MyClass { private x: number; }
28 >MyClass : Symbol(MyClass, Decl(index.ts, 0, 0))
29 >x : Symbol(MyClass.x, Decl(index.ts, 2, 22))
32 import {MyClass} from "library-a";
33 >MyClass : Symbol(MyClass, Decl(index.ts, 0, 8))
35 export { MyClass as MyClass2 }
[all …]
|
| D | derivedTypeCallingBaseImplWithOptionalParams.symbols | 9 class MyClass implements MyInterface {
10 >MyClass : Symbol(MyClass, Decl(derivedTypeCallingBaseImplWithOptionalParams.ts, 2, 1))
14 >myMethod : Symbol(MyClass.myMethod, Decl(derivedTypeCallingBaseImplWithOptionalParams.ts, 3, 38))
19 var x: MyInterface = new MyClass();
22 >MyClass : Symbol(MyClass, Decl(derivedTypeCallingBaseImplWithOptionalParams.ts, 2, 1))
24 x.myMethod(); // should be valid, but MyClass has no implementation to handle it.
29 var y: MyClass = new MyClass();
31 >MyClass : Symbol(MyClass, Decl(derivedTypeCallingBaseImplWithOptionalParams.ts, 2, 1))
32 >MyClass : Symbol(MyClass, Decl(derivedTypeCallingBaseImplWithOptionalParams.ts, 2, 1))
35 >y.myMethod : Symbol(MyClass.myMethod, Decl(derivedTypeCallingBaseImplWithOptionalParams.ts, 3, 38))
[all …]
|
| D | typeFromPropertyAssignment5.symbols | 2 export default function MyClass() {
3 >MyClass : Symbol(MyClass, Decl(a.js, 0, 0), Decl(a.js, 1, 1))
5 MyClass.bar = class C {
6 >MyClass.bar : Symbol(MyClass.bar, Decl(a.js, 1, 1))
7 >MyClass : Symbol(MyClass, Decl(a.js, 0, 0), Decl(a.js, 1, 1))
8 >bar : Symbol(MyClass.bar, Decl(a.js, 1, 1))
11 MyClass.bar
12 >MyClass.bar : Symbol(MyClass.bar, Decl(a.js, 1, 1))
13 >MyClass : Symbol(MyClass, Decl(a.js, 0, 0), Decl(a.js, 1, 1))
14 >bar : Symbol(MyClass.bar, Decl(a.js, 1, 1))
|
| D | moduleResolutionWithSymlinks_withOutDir.js | 6 export class MyClass { private x: number; } class
9 import {MyClass} from "library-a";
10 export { MyClass as MyClass2 }
13 import { MyClass } from "./library-a";
16 let x: MyClass;
26 exports.MyClass = void 0;
27 var MyClass = /** @class */ (function () {
28 function MyClass() { class in MyClass
30 return MyClass;
32 exports.MyClass = MyClass;
[all …]
|
| D | moduleResolutionWithSymlinks.js | 7 export class MyClass { private x: number; } class
10 import {MyClass} from "library-a";
11 export { MyClass as MyClass2 }
14 import { MyClass } from "./library-a";
17 let x: MyClass;
47 exports.MyClass = void 0;
48 var MyClass = /** @class */ (function () {
49 function MyClass() { class in MyClass
51 return MyClass;
53 exports.MyClass = MyClass;
[all …]
|
| D | importTypeInJSDoc.symbols | 2 declare namespace MyClass {
3 >MyClass : Symbol(MyClass, Decl(externs.d.ts, 0, 0), Decl(externs.d.ts, 4, 1))
13 declare class MyClass {
14 >MyClass : Symbol(MyClass, Decl(externs.d.ts, 0, 0), Decl(externs.d.ts, 4, 1))
17 >field : Symbol(MyClass.field, Decl(externs.d.ts, 5, 23))
20 >Bar : Symbol(MyClass.Bar, Decl(externs.d.ts, 0, 27), Decl(externs.d.ts, 6, 18))
24 constructor(x: MyClass.Bar);
26 >MyClass : Symbol(MyClass, Decl(externs.d.ts, 0, 0), Decl(externs.d.ts, 4, 1))
27 >Bar : Symbol(MyClass.Bar, Decl(externs.d.ts, 0, 27), Decl(externs.d.ts, 6, 18))
32 const Foo: typeof MyClass;
[all …]
|
| D | mappedTypePartialConstraints.types | 9 class MyClass<T extends MyInterface> {
10 >MyClass : MyClass<T>
17 class MySubClass extends MyClass<MyInterface> {}
19 >MyClass : MyClass<MyInterface>
21 function fn(arg: typeof MyClass) {};
22 >fn : (arg: typeof MyClass) => void
23 >arg : typeof MyClass
24 >MyClass : typeof MyClass
28 >fn : (arg: typeof MyClass) => void
|
| /third_party/flutter/engine/flutter/fml/memory/ |
| D | ref_counted_unittest.cc | 45 class MyClass : public RefCountedThreadSafe<MyClass> { class
47 MyClass(MyClass** created, bool* was_destroyed) in MyClass() function in fml::__anon934d1fc70111::MyClass
52 virtual ~MyClass() { in ~MyClass()
58 FML_FRIEND_REF_COUNTED_THREAD_SAFE(MyClass);
59 FML_FRIEND_MAKE_REF_COUNTED(MyClass);
63 FML_DISALLOW_COPY_AND_ASSIGN(MyClass);
66 class MySubclass final : public MyClass {
72 : MyClass(nullptr, was_destroyed) { in MySubclass()
86 RefPtr<MyClass> r; in TEST()
93 RefPtr<MyClass> r(nullptr); in TEST()
[all …]
|
| /third_party/typescript/tests/cases/conformance/types/thisType/ |
| D | thisTypeAccessibility.ts | 1 class MyClass { class
10 interface MyClass { interface
25 MyClass.prototype.extension1 = function (this: MyClass, p: number) {
29 MyClass.sp = p;
30 MyClass.spp = p;
31 MyClass.sppp = p;
34 MyClass.prototype.extension2 = function<T extends MyClass> (this: T, p: number) {
38 MyClass.sp = p;
39 MyClass.spp = p;
40 MyClass.sppp = p;
[all …]
|
| /third_party/typescript/tests/ts_extra_tests/test_ts_cases/spec/classes/class_declarations/ |
| D | class_declarations_3.ts | 23 class MyClass<T> { class
38 let mc1: MyClass<string> = new MyClass<string>("a");
41 let mc2: MyClass<number> = new MyClass<number>(1);
44 let mc3: MyClass<boolean> = new MyClass<boolean>(false);
48 let mc4: MyClass<Compute> = new MyClass<Compute>(p);
57 let mc5: MyClass<object> = new MyClass<object>(obj);
60 let mc6: MyClass<Array<number>> = new MyClass<Array<number>>(list);
|