From d71df3697809d875ad4b32c693f1a67e89dc3995 Mon Sep 17 00:00:00 2001 From: Jack Works Date: Sat, 27 Apr 2024 00:31:51 +0800 Subject: [PATCH] fix: no longer emit error for functions has no return statement under isolatedDeclarations --- src/compiler/expressionToTypeNode.ts | 3 + ...edDeclarationErrorsAugmentation.errors.txt | 6 +- .../isolatedDeclarationErrorsAugmentation.js | 10 + ...solatedDeclarationErrorsClasses.errors.txt | 52 +-- .../isolatedDeclarationErrorsClasses.js | 16 +- .../isolatedDeclarationErrorsClasses.symbols | 119 +++--- .../isolatedDeclarationErrorsClasses.types | 48 ++- ...clarationErrorsExpandoFunctions.errors.txt | 6 +- ...ationErrorsFunctionDeclarations.errors.txt | 6 +- ...solatedDeclarationErrorsObjects.errors.txt | 22 +- ...tedDeclarationErrorsReturnTypes.errors.txt | 361 ------------------ .../isolatedDeclarationErrorsReturnTypes.js | 116 ++++++ .../isolatedDeclarationLazySymbols.errors.txt | 6 +- .../isolatedDeclarationErrorsClasses.ts | 8 +- 14 files changed, 296 insertions(+), 483 deletions(-) delete mode 100644 tests/baselines/reference/isolatedDeclarationErrorsReturnTypes.errors.txt diff --git a/src/compiler/expressionToTypeNode.ts b/src/compiler/expressionToTypeNode.ts index a9f64a4919bc8..fc438894bb3b9 100644 --- a/src/compiler/expressionToTypeNode.ts +++ b/src/compiler/expressionToTypeNode.ts @@ -484,7 +484,9 @@ export function createSyntacticTypeNodeBuilder(options: CompilerOptions, resolve if (declaration && !nodeIsMissing(declaration.body)) { const body = declaration.body; if (body && isBlock(body)) { + let hasReturn = false; forEachReturnStatement(body, s => { + hasReturn = true; if (!candidateExpr) { candidateExpr = s.expression; } @@ -493,6 +495,7 @@ export function createSyntacticTypeNodeBuilder(options: CompilerOptions, resolve return true; } }); + if (!hasReturn) return true; // it's void } else { candidateExpr = body; diff --git a/tests/baselines/reference/isolatedDeclarationErrorsAugmentation.errors.txt b/tests/baselines/reference/isolatedDeclarationErrorsAugmentation.errors.txt index 4ccbc285f118c..9767df2447f46 100644 --- a/tests/baselines/reference/isolatedDeclarationErrorsAugmentation.errors.txt +++ b/tests/baselines/reference/isolatedDeclarationErrorsAugmentation.errors.txt @@ -1,8 +1,7 @@ -child1.ts(9,17): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. parent.ts(1,1): error TS9026: Declaration emit for this file requires preserving this import for augmentations. This is not supported with --isolatedDeclarations. -==== child1.ts (1 errors) ==== +==== child1.ts (0 errors) ==== import { ParentThing } from './parent'; declare module './parent' { @@ -12,9 +11,6 @@ parent.ts(1,1): error TS9026: Declaration emit for this file requires preserving } export function child1(prototype: ParentThing) { - ~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9031 child1.ts:9:17: Add a return type to the function declaration. prototype.add = (a: number, b: number) => a + b; } diff --git a/tests/baselines/reference/isolatedDeclarationErrorsAugmentation.js b/tests/baselines/reference/isolatedDeclarationErrorsAugmentation.js index 59d0b94817cef..e053262fccfd4 100644 --- a/tests/baselines/reference/isolatedDeclarationErrorsAugmentation.js +++ b/tests/baselines/reference/isolatedDeclarationErrorsAugmentation.js @@ -29,3 +29,13 @@ child1(ParentThing.prototype); export function child1(prototype) { prototype.add = (a, b) => a + b; } + + +//// [child1.d.ts] +import { ParentThing } from './parent'; +declare module './parent' { + interface ParentThing { + add: (a: number, b: number) => number; + } +} +export declare function child1(prototype: ParentThing): void; diff --git a/tests/baselines/reference/isolatedDeclarationErrorsClasses.errors.txt b/tests/baselines/reference/isolatedDeclarationErrorsClasses.errors.txt index a47466cbe991d..ccc1313d5884a 100644 --- a/tests/baselines/reference/isolatedDeclarationErrorsClasses.errors.txt +++ b/tests/baselines/reference/isolatedDeclarationErrorsClasses.errors.txt @@ -1,24 +1,24 @@ isolatedDeclarationErrorsClasses.ts(3,5): error TS9012: Property must have an explicit type annotation with --isolatedDeclarations. isolatedDeclarationErrorsClasses.ts(4,5): error TS9008: Method must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsClasses.ts(8,18): error TS7006: Parameter 'p' implicitly has an 'any' type. -isolatedDeclarationErrorsClasses.ts(8,18): error TS9011: Parameter must have an explicit type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsClasses.ts(9,23): error TS9011: Parameter must have an explicit type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsClasses.ts(11,9): error TS9009: At least one accessor must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsClasses.ts(12,9): error TS7032: Property 'setOnly' implicitly has type 'any', because its set accessor lacks a parameter type annotation. -isolatedDeclarationErrorsClasses.ts(12,17): error TS7006: Parameter 'value' implicitly has an 'any' type. -isolatedDeclarationErrorsClasses.ts(36,5): error TS1166: A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type. -isolatedDeclarationErrorsClasses.ts(36,6): error TS2304: Cannot find name 'missing'. -isolatedDeclarationErrorsClasses.ts(42,5): error TS9014: Computed properties must be number or string literals, variables or dotted expressions with --isolatedDeclarations. -isolatedDeclarationErrorsClasses.ts(44,5): error TS9014: Computed properties must be number or string literals, variables or dotted expressions with --isolatedDeclarations. -isolatedDeclarationErrorsClasses.ts(44,35): error TS7006: Parameter 'v' implicitly has an 'any' type. -isolatedDeclarationErrorsClasses.ts(46,9): error TS9014: Computed properties must be number or string literals, variables or dotted expressions with --isolatedDeclarations. -isolatedDeclarationErrorsClasses.ts(48,9): error TS7032: Property '[noParamAnnotationStringName]' implicitly has type 'any', because its set accessor lacks a parameter type annotation. -isolatedDeclarationErrorsClasses.ts(48,9): error TS9014: Computed properties must be number or string literals, variables or dotted expressions with --isolatedDeclarations. -isolatedDeclarationErrorsClasses.ts(48,39): error TS7006: Parameter 'value' implicitly has an 'any' type. -isolatedDeclarationErrorsClasses.ts(50,5): error TS1166: A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type. -isolatedDeclarationErrorsClasses.ts(55,5): error TS1169: A computed property name in an interface must refer to an expression whose type is a literal type or a 'unique symbol' type. -isolatedDeclarationErrorsClasses.ts(56,5): error TS7010: '[noAnnotationLiteralName]', which lacks return-type annotation, implicitly has an 'any' return type. -isolatedDeclarationErrorsClasses.ts(56,5): error TS9013: Expression type can't be inferred with --isolatedDeclarations. +isolatedDeclarationErrorsClasses.ts(12,18): error TS7006: Parameter 'p' implicitly has an 'any' type. +isolatedDeclarationErrorsClasses.ts(12,18): error TS9011: Parameter must have an explicit type annotation with --isolatedDeclarations. +isolatedDeclarationErrorsClasses.ts(13,23): error TS9011: Parameter must have an explicit type annotation with --isolatedDeclarations. +isolatedDeclarationErrorsClasses.ts(15,9): error TS9009: At least one accessor must have an explicit return type annotation with --isolatedDeclarations. +isolatedDeclarationErrorsClasses.ts(16,9): error TS7032: Property 'setOnly' implicitly has type 'any', because its set accessor lacks a parameter type annotation. +isolatedDeclarationErrorsClasses.ts(16,17): error TS7006: Parameter 'value' implicitly has an 'any' type. +isolatedDeclarationErrorsClasses.ts(40,5): error TS1166: A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type. +isolatedDeclarationErrorsClasses.ts(40,6): error TS2304: Cannot find name 'missing'. +isolatedDeclarationErrorsClasses.ts(46,5): error TS9014: Computed properties must be number or string literals, variables or dotted expressions with --isolatedDeclarations. +isolatedDeclarationErrorsClasses.ts(48,5): error TS9014: Computed properties must be number or string literals, variables or dotted expressions with --isolatedDeclarations. +isolatedDeclarationErrorsClasses.ts(48,35): error TS7006: Parameter 'v' implicitly has an 'any' type. +isolatedDeclarationErrorsClasses.ts(50,9): error TS9014: Computed properties must be number or string literals, variables or dotted expressions with --isolatedDeclarations. +isolatedDeclarationErrorsClasses.ts(52,9): error TS7032: Property '[noParamAnnotationStringName]' implicitly has type 'any', because its set accessor lacks a parameter type annotation. +isolatedDeclarationErrorsClasses.ts(52,9): error TS9014: Computed properties must be number or string literals, variables or dotted expressions with --isolatedDeclarations. +isolatedDeclarationErrorsClasses.ts(52,39): error TS7006: Parameter 'value' implicitly has an 'any' type. +isolatedDeclarationErrorsClasses.ts(54,5): error TS1166: A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type. +isolatedDeclarationErrorsClasses.ts(59,5): error TS1169: A computed property name in an interface must refer to an expression whose type is a literal type or a 'unique symbol' type. +isolatedDeclarationErrorsClasses.ts(60,5): error TS7010: '[noAnnotationLiteralName]', which lacks return-type annotation, implicitly has an 'any' return type. +isolatedDeclarationErrorsClasses.ts(60,5): error TS9013: Expression type can't be inferred with --isolatedDeclarations. ==== isolatedDeclarationErrorsClasses.ts (21 errors) ==== @@ -28,11 +28,15 @@ isolatedDeclarationErrorsClasses.ts(56,5): error TS9013: Expression type can't b ~~~~~ !!! error TS9012: Property must have an explicit type annotation with --isolatedDeclarations. !!! related TS9029 isolatedDeclarationErrorsClasses.ts:3:5: Add a type annotation to the property field. - method() {} + method() { return console.log() } ~~~~~~ !!! error TS9008: Method must have an explicit return type annotation with --isolatedDeclarations. !!! related TS9034 isolatedDeclarationErrorsClasses.ts:4:5: Add a return type to the method + methodImplicitVoid() { + if (Math.random() > 0.5) console.log() + else console.log() + } methodOk(): void {} methodParams(p): void {} @@ -40,16 +44,16 @@ isolatedDeclarationErrorsClasses.ts(56,5): error TS9013: Expression type can't b !!! error TS7006: Parameter 'p' implicitly has an 'any' type. ~ !!! error TS9011: Parameter must have an explicit type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsClasses.ts:8:18: Add a type annotation to the parameter p. +!!! related TS9028 isolatedDeclarationErrorsClasses.ts:12:18: Add a type annotation to the parameter p. methodParams2(p = 1 + 1): void {} ~~~~~ !!! error TS9011: Parameter must have an explicit type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsClasses.ts:9:19: Add a type annotation to the parameter p. +!!! related TS9028 isolatedDeclarationErrorsClasses.ts:13:19: Add a type annotation to the parameter p. get getOnly() { return 1 + 1 } ~~~~~~~ !!! error TS9009: At least one accessor must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9032 isolatedDeclarationErrorsClasses.ts:11:9: Add a return type to the get accessor declaration. +!!! related TS9032 isolatedDeclarationErrorsClasses.ts:15:9: Add a return type to the get accessor declaration. set setOnly(value) { } ~~~~~~~ !!! error TS7032: Property 'setOnly' implicitly has type 'any', because its set accessor lacks a parameter type annotation. @@ -83,7 +87,7 @@ isolatedDeclarationErrorsClasses.ts(56,5): error TS9013: Expression type can't b !!! error TS1166: A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type. ~~~~~~~ !!! error TS2304: Cannot find name 'missing'. - + [noAnnotationLiteralName](): void { } [noParamAnnotationLiteralName](v: string): void { } diff --git a/tests/baselines/reference/isolatedDeclarationErrorsClasses.js b/tests/baselines/reference/isolatedDeclarationErrorsClasses.js index 9be39e7476159..d91779bfa8039 100644 --- a/tests/baselines/reference/isolatedDeclarationErrorsClasses.js +++ b/tests/baselines/reference/isolatedDeclarationErrorsClasses.js @@ -4,8 +4,12 @@ export class Cls { field = 1 + 1; - method() {} + method() { return console.log() } + methodImplicitVoid() { + if (Math.random() > 0.5) console.log() + else console.log() + } methodOk(): void {} methodParams(p): void {} @@ -37,7 +41,7 @@ export class C { // Should not be reported as an isolated declaration error [missing] = 1; - + [noAnnotationLiteralName](): void { } [noParamAnnotationLiteralName](v: string): void { } @@ -62,7 +66,13 @@ export interface I { //// [isolatedDeclarationErrorsClasses.js] export class Cls { field = 1 + 1; - method() { } + method() { return console.log(); } + methodImplicitVoid() { + if (Math.random() > 0.5) + console.log(); + else + console.log(); + } methodOk() { } methodParams(p) { } methodParams2(p = 1 + 1) { } diff --git a/tests/baselines/reference/isolatedDeclarationErrorsClasses.symbols b/tests/baselines/reference/isolatedDeclarationErrorsClasses.symbols index 8a49eee4ad712..6aba4ed817815 100644 --- a/tests/baselines/reference/isolatedDeclarationErrorsClasses.symbols +++ b/tests/baselines/reference/isolatedDeclarationErrorsClasses.symbols @@ -7,115 +7,134 @@ export class Cls { field = 1 + 1; >field : Symbol(Cls.field, Decl(isolatedDeclarationErrorsClasses.ts, 0, 18)) - method() {} + method() { return console.log() } >method : Symbol(Cls.method, Decl(isolatedDeclarationErrorsClasses.ts, 2, 18)) - +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) + + methodImplicitVoid() { +>methodImplicitVoid : Symbol(Cls.methodImplicitVoid, Decl(isolatedDeclarationErrorsClasses.ts, 3, 37)) + + if (Math.random() > 0.5) console.log() +>Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) +>random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) + + else console.log() +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) + } methodOk(): void {} ->methodOk : Symbol(Cls.methodOk, Decl(isolatedDeclarationErrorsClasses.ts, 3, 15)) +>methodOk : Symbol(Cls.methodOk, Decl(isolatedDeclarationErrorsClasses.ts, 8, 5)) methodParams(p): void {} ->methodParams : Symbol(Cls.methodParams, Decl(isolatedDeclarationErrorsClasses.ts, 5, 23)) ->p : Symbol(p, Decl(isolatedDeclarationErrorsClasses.ts, 7, 17)) +>methodParams : Symbol(Cls.methodParams, Decl(isolatedDeclarationErrorsClasses.ts, 9, 23)) +>p : Symbol(p, Decl(isolatedDeclarationErrorsClasses.ts, 11, 17)) methodParams2(p = 1 + 1): void {} ->methodParams2 : Symbol(Cls.methodParams2, Decl(isolatedDeclarationErrorsClasses.ts, 7, 28)) ->p : Symbol(p, Decl(isolatedDeclarationErrorsClasses.ts, 8, 18)) +>methodParams2 : Symbol(Cls.methodParams2, Decl(isolatedDeclarationErrorsClasses.ts, 11, 28)) +>p : Symbol(p, Decl(isolatedDeclarationErrorsClasses.ts, 12, 18)) get getOnly() { return 1 + 1 } ->getOnly : Symbol(Cls.getOnly, Decl(isolatedDeclarationErrorsClasses.ts, 8, 37)) +>getOnly : Symbol(Cls.getOnly, Decl(isolatedDeclarationErrorsClasses.ts, 12, 37)) set setOnly(value) { } ->setOnly : Symbol(Cls.setOnly, Decl(isolatedDeclarationErrorsClasses.ts, 10, 34)) ->value : Symbol(value, Decl(isolatedDeclarationErrorsClasses.ts, 11, 16)) +>setOnly : Symbol(Cls.setOnly, Decl(isolatedDeclarationErrorsClasses.ts, 14, 34)) +>value : Symbol(value, Decl(isolatedDeclarationErrorsClasses.ts, 15, 16)) get getSetBad() { return 0 } ->getSetBad : Symbol(Cls.getSetBad, Decl(isolatedDeclarationErrorsClasses.ts, 11, 26), Decl(isolatedDeclarationErrorsClasses.ts, 13, 32)) +>getSetBad : Symbol(Cls.getSetBad, Decl(isolatedDeclarationErrorsClasses.ts, 15, 26), Decl(isolatedDeclarationErrorsClasses.ts, 17, 32)) set getSetBad(value) { } ->getSetBad : Symbol(Cls.getSetBad, Decl(isolatedDeclarationErrorsClasses.ts, 11, 26), Decl(isolatedDeclarationErrorsClasses.ts, 13, 32)) ->value : Symbol(value, Decl(isolatedDeclarationErrorsClasses.ts, 14, 18)) +>getSetBad : Symbol(Cls.getSetBad, Decl(isolatedDeclarationErrorsClasses.ts, 15, 26), Decl(isolatedDeclarationErrorsClasses.ts, 17, 32)) +>value : Symbol(value, Decl(isolatedDeclarationErrorsClasses.ts, 18, 18)) get getSetOk(): number { return 0 } ->getSetOk : Symbol(Cls.getSetOk, Decl(isolatedDeclarationErrorsClasses.ts, 14, 28), Decl(isolatedDeclarationErrorsClasses.ts, 16, 39)) +>getSetOk : Symbol(Cls.getSetOk, Decl(isolatedDeclarationErrorsClasses.ts, 18, 28), Decl(isolatedDeclarationErrorsClasses.ts, 20, 39)) set getSetOk(value) { } ->getSetOk : Symbol(Cls.getSetOk, Decl(isolatedDeclarationErrorsClasses.ts, 14, 28), Decl(isolatedDeclarationErrorsClasses.ts, 16, 39)) ->value : Symbol(value, Decl(isolatedDeclarationErrorsClasses.ts, 17, 17)) +>getSetOk : Symbol(Cls.getSetOk, Decl(isolatedDeclarationErrorsClasses.ts, 18, 28), Decl(isolatedDeclarationErrorsClasses.ts, 20, 39)) +>value : Symbol(value, Decl(isolatedDeclarationErrorsClasses.ts, 21, 17)) get getSetOk2() { return 0 } ->getSetOk2 : Symbol(Cls.getSetOk2, Decl(isolatedDeclarationErrorsClasses.ts, 17, 27), Decl(isolatedDeclarationErrorsClasses.ts, 19, 32)) +>getSetOk2 : Symbol(Cls.getSetOk2, Decl(isolatedDeclarationErrorsClasses.ts, 21, 27), Decl(isolatedDeclarationErrorsClasses.ts, 23, 32)) set getSetOk2(value: number) { } ->getSetOk2 : Symbol(Cls.getSetOk2, Decl(isolatedDeclarationErrorsClasses.ts, 17, 27), Decl(isolatedDeclarationErrorsClasses.ts, 19, 32)) ->value : Symbol(value, Decl(isolatedDeclarationErrorsClasses.ts, 20, 18)) +>getSetOk2 : Symbol(Cls.getSetOk2, Decl(isolatedDeclarationErrorsClasses.ts, 21, 27), Decl(isolatedDeclarationErrorsClasses.ts, 23, 32)) +>value : Symbol(value, Decl(isolatedDeclarationErrorsClasses.ts, 24, 18)) get getSetOk3(): number { return 0 } ->getSetOk3 : Symbol(Cls.getSetOk3, Decl(isolatedDeclarationErrorsClasses.ts, 20, 36), Decl(isolatedDeclarationErrorsClasses.ts, 22, 40)) +>getSetOk3 : Symbol(Cls.getSetOk3, Decl(isolatedDeclarationErrorsClasses.ts, 24, 36), Decl(isolatedDeclarationErrorsClasses.ts, 26, 40)) set getSetOk3(value: number) { } ->getSetOk3 : Symbol(Cls.getSetOk3, Decl(isolatedDeclarationErrorsClasses.ts, 20, 36), Decl(isolatedDeclarationErrorsClasses.ts, 22, 40)) ->value : Symbol(value, Decl(isolatedDeclarationErrorsClasses.ts, 23, 18)) +>getSetOk3 : Symbol(Cls.getSetOk3, Decl(isolatedDeclarationErrorsClasses.ts, 24, 36), Decl(isolatedDeclarationErrorsClasses.ts, 26, 40)) +>value : Symbol(value, Decl(isolatedDeclarationErrorsClasses.ts, 27, 18)) } let noAnnotationStringName: string = "noAnnotationStringName"; ->noAnnotationStringName : Symbol(noAnnotationStringName, Decl(isolatedDeclarationErrorsClasses.ts, 26, 3)) +>noAnnotationStringName : Symbol(noAnnotationStringName, Decl(isolatedDeclarationErrorsClasses.ts, 30, 3)) let noParamAnnotationStringName: string = "noParamAnnotationStringName"; ->noParamAnnotationStringName : Symbol(noParamAnnotationStringName, Decl(isolatedDeclarationErrorsClasses.ts, 27, 3)) +>noParamAnnotationStringName : Symbol(noParamAnnotationStringName, Decl(isolatedDeclarationErrorsClasses.ts, 31, 3)) const noAnnotationLiteralName = "noAnnotationLiteralName"; ->noAnnotationLiteralName : Symbol(noAnnotationLiteralName, Decl(isolatedDeclarationErrorsClasses.ts, 29, 5)) +>noAnnotationLiteralName : Symbol(noAnnotationLiteralName, Decl(isolatedDeclarationErrorsClasses.ts, 33, 5)) const noParamAnnotationLiteralName = "noParamAnnotationLiteralName"; ->noParamAnnotationLiteralName : Symbol(noParamAnnotationLiteralName, Decl(isolatedDeclarationErrorsClasses.ts, 30, 5)) +>noParamAnnotationLiteralName : Symbol(noParamAnnotationLiteralName, Decl(isolatedDeclarationErrorsClasses.ts, 34, 5)) export class C { ->C : Symbol(C, Decl(isolatedDeclarationErrorsClasses.ts, 30, 68)) +>C : Symbol(C, Decl(isolatedDeclarationErrorsClasses.ts, 34, 68)) // Should not be reported as an isolated declaration error [missing] = 1; ->[missing] : Symbol(C[missing], Decl(isolatedDeclarationErrorsClasses.ts, 32, 16)) - +>[missing] : Symbol(C[missing], Decl(isolatedDeclarationErrorsClasses.ts, 36, 16)) + [noAnnotationLiteralName](): void { } ->[noAnnotationLiteralName] : Symbol(C[noAnnotationLiteralName], Decl(isolatedDeclarationErrorsClasses.ts, 35, 18)) ->noAnnotationLiteralName : Symbol(noAnnotationLiteralName, Decl(isolatedDeclarationErrorsClasses.ts, 29, 5)) +>[noAnnotationLiteralName] : Symbol(C[noAnnotationLiteralName], Decl(isolatedDeclarationErrorsClasses.ts, 39, 18)) +>noAnnotationLiteralName : Symbol(noAnnotationLiteralName, Decl(isolatedDeclarationErrorsClasses.ts, 33, 5)) [noParamAnnotationLiteralName](v: string): void { } ->[noParamAnnotationLiteralName] : Symbol(C[noParamAnnotationLiteralName], Decl(isolatedDeclarationErrorsClasses.ts, 37, 41)) ->noParamAnnotationLiteralName : Symbol(noParamAnnotationLiteralName, Decl(isolatedDeclarationErrorsClasses.ts, 30, 5)) ->v : Symbol(v, Decl(isolatedDeclarationErrorsClasses.ts, 39, 35)) +>[noParamAnnotationLiteralName] : Symbol(C[noParamAnnotationLiteralName], Decl(isolatedDeclarationErrorsClasses.ts, 41, 41)) +>noParamAnnotationLiteralName : Symbol(noParamAnnotationLiteralName, Decl(isolatedDeclarationErrorsClasses.ts, 34, 5)) +>v : Symbol(v, Decl(isolatedDeclarationErrorsClasses.ts, 43, 35)) [noAnnotationStringName]() { } ->[noAnnotationStringName] : Symbol(C[noAnnotationStringName], Decl(isolatedDeclarationErrorsClasses.ts, 39, 55)) ->noAnnotationStringName : Symbol(noAnnotationStringName, Decl(isolatedDeclarationErrorsClasses.ts, 26, 3)) +>[noAnnotationStringName] : Symbol(C[noAnnotationStringName], Decl(isolatedDeclarationErrorsClasses.ts, 43, 55)) +>noAnnotationStringName : Symbol(noAnnotationStringName, Decl(isolatedDeclarationErrorsClasses.ts, 30, 3)) [noParamAnnotationStringName](v): void { } ->[noParamAnnotationStringName] : Symbol(C[noParamAnnotationStringName], Decl(isolatedDeclarationErrorsClasses.ts, 41, 34)) ->noParamAnnotationStringName : Symbol(noParamAnnotationStringName, Decl(isolatedDeclarationErrorsClasses.ts, 27, 3)) ->v : Symbol(v, Decl(isolatedDeclarationErrorsClasses.ts, 43, 34)) +>[noParamAnnotationStringName] : Symbol(C[noParamAnnotationStringName], Decl(isolatedDeclarationErrorsClasses.ts, 45, 34)) +>noParamAnnotationStringName : Symbol(noParamAnnotationStringName, Decl(isolatedDeclarationErrorsClasses.ts, 31, 3)) +>v : Symbol(v, Decl(isolatedDeclarationErrorsClasses.ts, 47, 34)) get [noAnnotationStringName]() { return 0;} ->[noAnnotationStringName] : Symbol(C[noAnnotationStringName], Decl(isolatedDeclarationErrorsClasses.ts, 43, 46)) ->noAnnotationStringName : Symbol(noAnnotationStringName, Decl(isolatedDeclarationErrorsClasses.ts, 26, 3)) +>[noAnnotationStringName] : Symbol(C[noAnnotationStringName], Decl(isolatedDeclarationErrorsClasses.ts, 47, 46)) +>noAnnotationStringName : Symbol(noAnnotationStringName, Decl(isolatedDeclarationErrorsClasses.ts, 30, 3)) set [noParamAnnotationStringName](value) { } ->[noParamAnnotationStringName] : Symbol(C[noParamAnnotationStringName], Decl(isolatedDeclarationErrorsClasses.ts, 45, 47)) ->noParamAnnotationStringName : Symbol(noParamAnnotationStringName, Decl(isolatedDeclarationErrorsClasses.ts, 27, 3)) ->value : Symbol(value, Decl(isolatedDeclarationErrorsClasses.ts, 47, 38)) +>[noParamAnnotationStringName] : Symbol(C[noParamAnnotationStringName], Decl(isolatedDeclarationErrorsClasses.ts, 49, 47)) +>noParamAnnotationStringName : Symbol(noParamAnnotationStringName, Decl(isolatedDeclarationErrorsClasses.ts, 31, 3)) +>value : Symbol(value, Decl(isolatedDeclarationErrorsClasses.ts, 51, 38)) [("A" + "B") as "AB"] = 1; ->[("A" + "B") as "AB"] : Symbol(C[("A" + "B") as "AB"], Decl(isolatedDeclarationErrorsClasses.ts, 47, 48)) +>[("A" + "B") as "AB"] : Symbol(C[("A" + "B") as "AB"], Decl(isolatedDeclarationErrorsClasses.ts, 51, 48)) } export interface I { ->I : Symbol(I, Decl(isolatedDeclarationErrorsClasses.ts, 51, 1)) +>I : Symbol(I, Decl(isolatedDeclarationErrorsClasses.ts, 55, 1)) [noAnnotationStringName]: 10; ->[noAnnotationStringName] : Symbol(I[noAnnotationStringName], Decl(isolatedDeclarationErrorsClasses.ts, 53, 20)) ->noAnnotationStringName : Symbol(noAnnotationStringName, Decl(isolatedDeclarationErrorsClasses.ts, 26, 3)) +>[noAnnotationStringName] : Symbol(I[noAnnotationStringName], Decl(isolatedDeclarationErrorsClasses.ts, 57, 20)) +>noAnnotationStringName : Symbol(noAnnotationStringName, Decl(isolatedDeclarationErrorsClasses.ts, 30, 3)) [noAnnotationLiteralName](); ->[noAnnotationLiteralName] : Symbol(I[noAnnotationLiteralName], Decl(isolatedDeclarationErrorsClasses.ts, 54, 33)) ->noAnnotationLiteralName : Symbol(noAnnotationLiteralName, Decl(isolatedDeclarationErrorsClasses.ts, 29, 5)) +>[noAnnotationLiteralName] : Symbol(I[noAnnotationLiteralName], Decl(isolatedDeclarationErrorsClasses.ts, 58, 33)) +>noAnnotationLiteralName : Symbol(noAnnotationLiteralName, Decl(isolatedDeclarationErrorsClasses.ts, 33, 5)) } diff --git a/tests/baselines/reference/isolatedDeclarationErrorsClasses.types b/tests/baselines/reference/isolatedDeclarationErrorsClasses.types index aa310b6119e7c..6e2d2bdb5fec3 100644 --- a/tests/baselines/reference/isolatedDeclarationErrorsClasses.types +++ b/tests/baselines/reference/isolatedDeclarationErrorsClasses.types @@ -15,10 +15,54 @@ export class Cls { >1 : 1 > : ^ - method() {} + method() { return console.log() } >method : () => void > : ^^^^^^^^^^ +>console.log() : void +> : ^^^^ +>console.log : (...data: any[]) => void +> : ^^^^ ^^ ^^^^^^^^^ +>console : Console +> : ^^^^^^^ +>log : (...data: any[]) => void +> : ^^^^ ^^ ^^^^^^^^^ + methodImplicitVoid() { +>methodImplicitVoid : () => void +> : ^^^^^^^^^^ + + if (Math.random() > 0.5) console.log() +>Math.random() > 0.5 : boolean +> : ^^^^^^^ +>Math.random() : number +> : ^^^^^^ +>Math.random : () => number +> : ^^^^^^^^^^^^ +>Math : Math +> : ^^^^ +>random : () => number +> : ^^^^^^^^^^^^ +>0.5 : 0.5 +> : ^^^ +>console.log() : void +> : ^^^^ +>console.log : (...data: any[]) => void +> : ^^^^ ^^ ^^^^^^^^^ +>console : Console +> : ^^^^^^^ +>log : (...data: any[]) => void +> : ^^^^ ^^ ^^^^^^^^^ + + else console.log() +>console.log() : void +> : ^^^^ +>console.log : (...data: any[]) => void +> : ^^^^ ^^ ^^^^^^^^^ +>console : Console +> : ^^^^^^^ +>log : (...data: any[]) => void +> : ^^^^ ^^ ^^^^^^^^^ + } methodOk(): void {} >methodOk : () => void > : ^^^^^^ @@ -142,7 +186,7 @@ export class C { > : ^^^ >1 : 1 > : ^ - + [noAnnotationLiteralName](): void { } >[noAnnotationLiteralName] : () => void > : ^^^^^^ diff --git a/tests/baselines/reference/isolatedDeclarationErrorsExpandoFunctions.errors.txt b/tests/baselines/reference/isolatedDeclarationErrorsExpandoFunctions.errors.txt index adc2ffbf0df9a..6ab24b85860e7 100644 --- a/tests/baselines/reference/isolatedDeclarationErrorsExpandoFunctions.errors.txt +++ b/tests/baselines/reference/isolatedDeclarationErrorsExpandoFunctions.errors.txt @@ -1,4 +1,3 @@ -isolatedDeclarationErrorsExpandoFunctions.ts(1,17): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. isolatedDeclarationErrorsExpandoFunctions.ts(3,1): error TS9023: Assigning properties to functions without declaring them is not supported with --isolatedDeclarations. Add an explicit declaration for the properties assigned to this function. isolatedDeclarationErrorsExpandoFunctions.ts(4,1): error TS9023: Assigning properties to functions without declaring them is not supported with --isolatedDeclarations. Add an explicit declaration for the properties assigned to this function. isolatedDeclarationErrorsExpandoFunctions.ts(5,1): error TS9023: Assigning properties to functions without declaring them is not supported with --isolatedDeclarations. Add an explicit declaration for the properties assigned to this function. @@ -7,11 +6,8 @@ isolatedDeclarationErrorsExpandoFunctions.ts(7,1): error TS9023: Assigning prope isolatedDeclarationErrorsExpandoFunctions.ts(8,1): error TS9023: Assigning properties to functions without declaring them is not supported with --isolatedDeclarations. Add an explicit declaration for the properties assigned to this function. -==== isolatedDeclarationErrorsExpandoFunctions.ts (7 errors) ==== +==== isolatedDeclarationErrorsExpandoFunctions.ts (6 errors) ==== export function foo() {} - ~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9031 isolatedDeclarationErrorsExpandoFunctions.ts:1:17: Add a return type to the function declaration. foo.apply = () => {} ~~~~~~~~~ diff --git a/tests/baselines/reference/isolatedDeclarationErrorsFunctionDeclarations.errors.txt b/tests/baselines/reference/isolatedDeclarationErrorsFunctionDeclarations.errors.txt index cbec933ded031..3d3b066c1a8ee 100644 --- a/tests/baselines/reference/isolatedDeclarationErrorsFunctionDeclarations.errors.txt +++ b/tests/baselines/reference/isolatedDeclarationErrorsFunctionDeclarations.errors.txt @@ -1,4 +1,3 @@ -isolatedDeclarationErrorsFunctionDeclarations.ts(1,17): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. isolatedDeclarationErrorsFunctionDeclarations.ts(3,35): error TS9011: Parameter must have an explicit type annotation with --isolatedDeclarations. isolatedDeclarationErrorsFunctionDeclarations.ts(7,49): error TS9011: Parameter must have an explicit type annotation with --isolatedDeclarations. isolatedDeclarationErrorsFunctionDeclarations.ts(7,66): error TS9013: Expression type can't be inferred with --isolatedDeclarations. @@ -6,11 +5,8 @@ isolatedDeclarationErrorsFunctionDeclarations.ts(7,81): error TS9013: Expression isolatedDeclarationErrorsFunctionDeclarations.ts(9,55): error TS9013: Expression type can't be inferred with --isolatedDeclarations. -==== isolatedDeclarationErrorsFunctionDeclarations.ts (6 errors) ==== +==== isolatedDeclarationErrorsFunctionDeclarations.ts (5 errors) ==== export function noReturn() {} - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9031 isolatedDeclarationErrorsFunctionDeclarations.ts:1:17: Add a return type to the function declaration. export function noParamAnnotation(p): void {} ~ diff --git a/tests/baselines/reference/isolatedDeclarationErrorsObjects.errors.txt b/tests/baselines/reference/isolatedDeclarationErrorsObjects.errors.txt index 26872afa9eb44..27c2765108879 100644 --- a/tests/baselines/reference/isolatedDeclarationErrorsObjects.errors.txt +++ b/tests/baselines/reference/isolatedDeclarationErrorsObjects.errors.txt @@ -1,11 +1,7 @@ isolatedDeclarationErrorsObjects.ts(7,8): error TS9013: Expression type can't be inferred with --isolatedDeclarations. isolatedDeclarationErrorsObjects.ts(12,12): error TS9013: Expression type can't be inferred with --isolatedDeclarations. isolatedDeclarationErrorsObjects.ts(16,12): error TS9013: Expression type can't be inferred with --isolatedDeclarations. -isolatedDeclarationErrorsObjects.ts(21,5): error TS9008: Method must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsObjects.ts(24,5): error TS9008: Method must have an explicit return type annotation with --isolatedDeclarations. isolatedDeclarationErrorsObjects.ts(25,8): error TS9013: Expression type can't be inferred with --isolatedDeclarations. -isolatedDeclarationErrorsObjects.ts(29,9): error TS9008: Method must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsObjects.ts(32,9): error TS9008: Method must have an explicit return type annotation with --isolatedDeclarations. isolatedDeclarationErrorsObjects.ts(40,9): error TS7032: Property 'singleSetterBad' implicitly has type 'any', because its set accessor lacks a parameter type annotation. isolatedDeclarationErrorsObjects.ts(40,25): error TS7006: Parameter 'value' implicitly has an 'any' type. isolatedDeclarationErrorsObjects.ts(40,25): error TS9009: At least one accessor must have an explicit return type annotation with --isolatedDeclarations. @@ -16,7 +12,7 @@ isolatedDeclarationErrorsObjects.ts(77,5): error TS9016: Objects that contain sh isolatedDeclarationErrorsObjects.ts(84,9): error TS9015: Objects that contain spread assignments can't be inferred with --isolatedDeclarations. -==== isolatedDeclarationErrorsObjects.ts (16 errors) ==== +==== isolatedDeclarationErrorsObjects.ts (12 errors) ==== export let o = { a: 1, b: "" @@ -50,17 +46,9 @@ isolatedDeclarationErrorsObjects.ts(84,9): error TS9015: Objects that contain sp export let oWithMethods = { method() { }, - ~~~~~~ -!!! error TS9008: Method must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9027 isolatedDeclarationErrorsObjects.ts:20:12: Add a type annotation to the variable oWithMethods. -!!! related TS9034 isolatedDeclarationErrorsObjects.ts:21:5: Add a return type to the method okMethod(): void { }, a: 1, bad() { }, - ~~~ -!!! error TS9008: Method must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9027 isolatedDeclarationErrorsObjects.ts:20:12: Add a type annotation to the variable oWithMethods. -!!! related TS9034 isolatedDeclarationErrorsObjects.ts:24:5: Add a return type to the method e: V, ~ !!! error TS9013: Expression type can't be inferred with --isolatedDeclarations. @@ -70,17 +58,9 @@ isolatedDeclarationErrorsObjects.ts(84,9): error TS9015: Objects that contain sp export let oWithMethodsNested = { foo: { method() { }, - ~~~~~~ -!!! error TS9008: Method must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9027 isolatedDeclarationErrorsObjects.ts:27:12: Add a type annotation to the variable oWithMethodsNested. -!!! related TS9034 isolatedDeclarationErrorsObjects.ts:29:9: Add a return type to the method a: 1, okMethod(): void { }, bad() { } - ~~~ -!!! error TS9008: Method must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9027 isolatedDeclarationErrorsObjects.ts:27:12: Add a type annotation to the variable oWithMethodsNested. -!!! related TS9034 isolatedDeclarationErrorsObjects.ts:32:9: Add a return type to the method } } diff --git a/tests/baselines/reference/isolatedDeclarationErrorsReturnTypes.errors.txt b/tests/baselines/reference/isolatedDeclarationErrorsReturnTypes.errors.txt deleted file mode 100644 index 4981a650dbc48..0000000000000 --- a/tests/baselines/reference/isolatedDeclarationErrorsReturnTypes.errors.txt +++ /dev/null @@ -1,361 +0,0 @@ -isolatedDeclarationErrorsReturnTypes.ts(13,45): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(16,41): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(19,41): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(109,65): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(112,61): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(115,61): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(119,83): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(120,66): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(122,79): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(123,62): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(125,79): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(126,62): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(138,73): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(141,69): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(144,69): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(151,38): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(152,21): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(153,57): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(154,40): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(156,51): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(157,34): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(158,70): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(159,53): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(162,53): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(163,36): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(164,72): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(165,55): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(167,66): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(168,49): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(169,85): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -isolatedDeclarationErrorsReturnTypes.ts(170,68): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. - - -==== isolatedDeclarationErrorsReturnTypes.ts (31 errors) ==== - // Function Variables - export const fnExpressionConstVariable = function foo() { return 0;} - export const fnArrowConstVariable = () => "S"; - - export let fnExpressionLetVariable = function foo() { return 0;} - export let fnArrowLetVariable = () => "S"; - - export var fnExpressionVarVariable = function foo() { return 0;} - export var fnArrowVarVariable = () => "S"; - - // No Errors - export const fnExpressionConstVariableOk = function foo(): number { return 0;} - export const fnArrowConstVariableOk = (cb = function(){ }): string => "S"; - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:13:40: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:13:45: Add a return type to the function expression. - - export let fnExpressionLetVariableOk = function foo(): number { return 0;} - export let fnArrowLetVariableOk = (cb = function(){ }): string => "S"; - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:16:36: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:16:41: Add a return type to the function expression. - - export var fnExpressionVarVariableOk = function foo(): number { return 0;} - export var fnArrowVarVariableOk = (cb = function(){ }): string => "S"; - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:19:36: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:19:41: Add a return type to the function expression. - - // Not exported - const fnExpressionConstVariableInternal = function foo() { return 0;} - const fnArrowConstVariableInternal = () => "S"; - - let fnExpressionLetVariableInternal = function foo() { return 0;} - let fnArrowLetVariableInternal = () => "S"; - - var fnExpressionVarVariableInternal = function foo() { return 0;} - var fnArrowVarVariableInternal = () => "S"; - - // Function Fields - export class ExportedClass { - // Should Error - fnExpression = function foo() { return 0; } - fnArrow = () => "S"; - protected fnExpressionProtected = function foo() { return 0; } - protected fnArrowProtected = () => "S"; - - static fnStaticExpression = function foo() { return 0; } - static fnStaticArrow = () => "S"; - protected static fnStaticExpressionProtected = function foo() { return 0; } - protected static fnStaticArrowProtected = () => "S"; - - // Have annotation, so ok - fnExpressionOk = function foo(): number { return 0; } - fnArrowOK = (): string => "S"; - protected fnExpressionProtectedOk = function foo(): number { return 0; } - protected fnArrowProtectedOK = (): string => "S"; - - static fnStaticExpressionOk = function foo(): number { return 0; } - static fnStaticArrowOk = (): string => "S"; - protected static fnStaticExpressionProtectedOk = function foo(): number { return 0; } - protected static fnStaticArrowProtectedOk = (): string => "S"; - - - // No Error not in declarations - private fnExpressionPrivate = function foo() { return 0; } - private fnArrowPrivate = () => "S"; - #fnArrow = () => "S"; - #fnExpression = function foo() { return 0;} - private static fnStaticExpressionPrivate = function foo() { return 0; } - private static fnStaticArrowPrivate = () => "S"; - } - - // Should error - class IndirectlyExportedClass { - fnExpression = function foo() { return 0; } - fnArrow = () => "S"; - - static fnStaticExpression = function foo() { return 0; } - static fnStaticArrow = () => "S"; - - protected static fnStaticExpressionProtected = function foo() { return 0; } - protected static fnStaticArrowProtected = () => "S"; - - private fnExpressionPrivate = function foo() { return 0; } - private fnArrowPrivate = () => "S"; - #fnArrow = () => "S"; - #fnExpression = function foo() { return 0;} - private static fnStaticExpressionPrivate = function foo() { return 0; } - private static fnStaticArrowPrivate = () => "S"; - } - export const instance: IndirectlyExportedClass = new IndirectlyExportedClass(); - - // No Errors - class InternalClass { - fnExpression = function foo() { return 0; } - fnArrow = () => "S"; - - static fnStaticExpression = function foo() { return 0; } - static fnStaticArrow = () => "S"; - - protected static fnStaticExpressionProtected = function foo() { return 0; } - protected static fnStaticArrowProtected = () => "S"; - - private fnExpressionPrivate = function foo() { return 0; } - private fnArrowPrivate = () => "S"; - #fnArrow = () => "S"; - #fnExpression = function foo() { return 0;} - private static fnStaticExpressionPrivate = function foo() { return 0; } - private static fnStaticArrowPrivate = () => "S"; - } - const internalInstance: InternalClass = new InternalClass(); - - - // Function parameters - - // In Function Variables - No annotations - export const fnParamExpressionConstVariable = function foo(cb = function(){ }) { return 0;} - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:109:60: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:109:65: Add a return type to the function expression. - export const fnParamArrowConstVariable = (cb = () => 1) => "S"; - - export let fnParamExpressionLetVariable = function foo(cb = function(){ }) { return 0;} - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:112:56: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:112:61: Add a return type to the function expression. - export let fnParamArrowLetVariable = (cb = () => 1) => "S"; - - export var fnParamExpressionVarVariable = function foo(cb = function(){ }) { return 0;} - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:115:56: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:115:61: Add a return type to the function expression. - export var fnParamArrowVarVariable = (cb = () => 1) => "S"; - - // In Function Variables - No annotations on parameter - export const fnParamExpressionConstVariableOwnerHasReturnType = function foo(cb = function(){ }): number { return 0;} - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:119:78: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:119:83: Add a return type to the function expression. - export const fnParamArrowConstVariableOwnerHasReturnType = (cb = function(){ }): string => "S"; - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:120:61: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:120:66: Add a return type to the function expression. - - export let fnParamExpressionLetVariableOwnerHasReturnType = function foo(cb = function(){ }): number { return 0;} - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:122:74: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:122:79: Add a return type to the function expression. - export let fnParamArrowLetVariableOwnerHasReturnType = (cb = function(){ }): string => "S"; - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:123:57: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:123:62: Add a return type to the function expression. - - export var fnParamExpressionVarVariableOwnerHasReturnType = function foo(cb = function(){ }): number { return 0;} - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:125:74: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:125:79: Add a return type to the function expression. - export var fnParamArrowVarVariableOwnerHasReturnType = (cb = function(){ }): string => "S"; - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:126:57: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:126:62: Add a return type to the function expression. - - // No Errors - export const fnParamExpressionConstVariableOk = function foo(cb = function(): void{ }): number { return 0;} - export const fnParamArrowConstVariableOk = (cb = function(): void{ }): string => "S"; - - export let fnParamExpressionLetVariableOk = function foo(cb = function(): void{ }): number { return 0;} - export let fnParamArrowLetVariableOk = (cb = function(): void{ }): string => "S"; - - export var fnParamExpressionVarVariableOk = function foo(cb = function(): void{ }): number { return 0;} - export var fnParamArrowVarVariableOk = (cb = function(): void{ }): string => "S"; - - export const fnParamExpressionConstVariableInternal = function foo(cb = function(){ }) { return 0;} - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:138:68: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:138:73: Add a return type to the function expression. - export const fnParamArrowConstVariableInternal = (cb = () => 1) => "S"; - - export let fnParamExpressionLetVariableInternal = function foo(cb = function(){ }) { return 0;} - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:141:64: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:141:69: Add a return type to the function expression. - export let fnParamArrowLetVariableInternal = (cb = () => 1) => "S"; - - export var fnParamExpressionVarVariableInternal = function foo(cb = function(){ }) { return 0;} - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:144:64: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:144:69: Add a return type to the function expression. - export var fnParamArrowVarVariableInternal = (cb = () => 1) => "S"; - - - // In Function Fields - export class FnParamsExportedClass { - // Should Error - fnExpression = function foo(cb = function(){ }) { return 0; } - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:151:33: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:151:38: Add a return type to the function expression. - fnArrow = (cb = function(){ }) => "S"; - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:152:16: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:152:21: Add a return type to the function expression. - protected fnExpressionProtected = function foo(cb = function(){ }) { return 0; } - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:153:52: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:153:57: Add a return type to the function expression. - protected fnArrowProtected = (cb = function(){ }) => "S"; - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:154:35: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:154:40: Add a return type to the function expression. - - static fnStaticExpression = function foo(cb = function(){ }) { return 0; } - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:156:46: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:156:51: Add a return type to the function expression. - static fnStaticArrow = (cb = function(){ }) => "S"; - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:157:29: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:157:34: Add a return type to the function expression. - protected static fnStaticExpressionProtected = function foo(cb = function(){ }) { return 0; } - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:158:65: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:158:70: Add a return type to the function expression. - protected static fnStaticArrowProtected = (cb = function(){ }) => "S"; - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:159:48: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:159:53: Add a return type to the function expression. - - // Have annotation on owner - fnExpressionMethodHasReturn = function foo(cb = function(){ }): number { return 0; } - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:162:48: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:162:53: Add a return type to the function expression. - fnArrowMethodHasReturn = (cb = function(){ }): string => "S"; - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:163:31: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:163:36: Add a return type to the function expression. - protected fnExpressionProtectedMethodHasReturn = function foo(cb = function(){ }): number { return 0; } - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:164:67: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:164:72: Add a return type to the function expression. - protected fnArrowProtectedMethodHasReturn = (cb = function(){ }): string => "S"; - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:165:50: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:165:55: Add a return type to the function expression. - - static fnStaticExpressionMethodHasReturn = function foo(cb = function(){ }): number { return 0; } - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:167:61: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:167:66: Add a return type to the function expression. - static fnStaticArrowMethodHasReturn = (cb = function(){ }): string => "S"; - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:168:44: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:168:49: Add a return type to the function expression. - protected static fnStaticExpressionProtectedMethodHasReturn = function foo(cb = function(){ }): number { return 0; } - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:169:80: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:169:85: Add a return type to the function expression. - protected static fnStaticArrowProtectedMethodHasReturn = (cb = function(){ }): string => "S"; - ~~~~~~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9028 isolatedDeclarationErrorsReturnTypes.ts:170:63: Add a type annotation to the parameter cb. -!!! related TS9030 isolatedDeclarationErrorsReturnTypes.ts:170:68: Add a return type to the function expression. - - // Have annotation only on parameter - fnExpressionOnlyOnParam = function foo(cb = function(): void { }) { return 0; } - fnArrowOnlyOnParam = (cb = function(): void { }) => "S"; - protected fnExpressionProtectedOnlyOnParam = function foo(cb = function(): void { }) { return 0; } - protected fnArrowProtectedOnlyOnParam = (cb = function(): void { }) => "S"; - - static fnStaticExpressionOnlyOnParam = function foo(cb = function(): void{ }) { return 0; } - static fnStaticArrowOnlyOnParam = (cb = function(): void{ }) => "S"; - protected static fnStaticExpressionProtectedOnlyOnParam = function foo(cb = function(): void{ }) { return 0; } - protected static fnStaticArrowProtectedOnlyOnParam = (cb = function(): void{ }) => "S"; - - // Have annotation, so ok - fnExpressionOk = function foo(cb = function(): void { }): number { return 0; } - fnArrowOK = (cb = function(): void { }): string => "S"; - protected fnExpressionProtectedOk = function foo(cb = function(): void { }): number { return 0; } - protected fnArrowProtectedOK = (cb = function(): void { }): string => "S"; - - static fnStaticExpressionOk = function foo(cb = function(): void{ }): number { return 0; } - static fnStaticArrowOk = (cb = function(): void{ }): string => "S"; - protected static fnStaticExpressionProtectedOk = function foo(cb = function(): void{ }): number { return 0; } - protected static fnStaticArrowProtectedOk = (cb = function(): void{ }): string => "S"; - - - // No Error, not in declarations - private fnExpressionPrivate = function foo(cb = function(){ }) { return 0; } - private fnArrowPrivate = (cb = function(){ }) => "S"; - #fnArrow = (cb = function(){ }) => "S"; - #fnExpression = function foo(cb = function(){ }) { return 0;} - private static fnStaticExpressionPrivate = function foo(cb = function(){ }) { return 0; } - private static fnStaticArrowPrivate = (cb = function(){ }) => "S"; - } - \ No newline at end of file diff --git a/tests/baselines/reference/isolatedDeclarationErrorsReturnTypes.js b/tests/baselines/reference/isolatedDeclarationErrorsReturnTypes.js index 8dd9ad0d8a0c6..b51c38dc6d239 100644 --- a/tests/baselines/reference/isolatedDeclarationErrorsReturnTypes.js +++ b/tests/baselines/reference/isolatedDeclarationErrorsReturnTypes.js @@ -361,3 +361,119 @@ export class FnParamsExportedClass { static fnStaticExpressionPrivate = function foo(cb = function () { }) { return 0; }; static fnStaticArrowPrivate = (cb = function () { }) => "S"; } + + +//// [isolatedDeclarationErrorsReturnTypes.d.ts] +export declare const fnExpressionConstVariable: () => number; +export declare const fnArrowConstVariable: () => string; +export declare let fnExpressionLetVariable: () => number; +export declare let fnArrowLetVariable: () => string; +export declare var fnExpressionVarVariable: () => number; +export declare var fnArrowVarVariable: () => string; +export declare const fnExpressionConstVariableOk: () => number; +export declare const fnArrowConstVariableOk: (cb?: () => void) => string; +export declare let fnExpressionLetVariableOk: () => number; +export declare let fnArrowLetVariableOk: (cb?: () => void) => string; +export declare var fnExpressionVarVariableOk: () => number; +export declare var fnArrowVarVariableOk: (cb?: () => void) => string; +export declare class ExportedClass { + #private; + fnExpression: () => number; + fnArrow: () => string; + protected fnExpressionProtected: () => number; + protected fnArrowProtected: () => string; + static fnStaticExpression: () => number; + static fnStaticArrow: () => string; + protected static fnStaticExpressionProtected: () => number; + protected static fnStaticArrowProtected: () => string; + fnExpressionOk: () => number; + fnArrowOK: () => string; + protected fnExpressionProtectedOk: () => number; + protected fnArrowProtectedOK: () => string; + static fnStaticExpressionOk: () => number; + static fnStaticArrowOk: () => string; + protected static fnStaticExpressionProtectedOk: () => number; + protected static fnStaticArrowProtectedOk: () => string; + private fnExpressionPrivate; + private fnArrowPrivate; + private static fnStaticExpressionPrivate; + private static fnStaticArrowPrivate; +} +declare class IndirectlyExportedClass { + #private; + fnExpression: () => number; + fnArrow: () => string; + static fnStaticExpression: () => number; + static fnStaticArrow: () => string; + protected static fnStaticExpressionProtected: () => number; + protected static fnStaticArrowProtected: () => string; + private fnExpressionPrivate; + private fnArrowPrivate; + private static fnStaticExpressionPrivate; + private static fnStaticArrowPrivate; +} +export declare const instance: IndirectlyExportedClass; +export declare const fnParamExpressionConstVariable: (cb?: () => void) => number; +export declare const fnParamArrowConstVariable: (cb?: () => number) => string; +export declare let fnParamExpressionLetVariable: (cb?: () => void) => number; +export declare let fnParamArrowLetVariable: (cb?: () => number) => string; +export declare var fnParamExpressionVarVariable: (cb?: () => void) => number; +export declare var fnParamArrowVarVariable: (cb?: () => number) => string; +export declare const fnParamExpressionConstVariableOwnerHasReturnType: (cb?: () => void) => number; +export declare const fnParamArrowConstVariableOwnerHasReturnType: (cb?: () => void) => string; +export declare let fnParamExpressionLetVariableOwnerHasReturnType: (cb?: () => void) => number; +export declare let fnParamArrowLetVariableOwnerHasReturnType: (cb?: () => void) => string; +export declare var fnParamExpressionVarVariableOwnerHasReturnType: (cb?: () => void) => number; +export declare var fnParamArrowVarVariableOwnerHasReturnType: (cb?: () => void) => string; +export declare const fnParamExpressionConstVariableOk: (cb?: () => void) => number; +export declare const fnParamArrowConstVariableOk: (cb?: () => void) => string; +export declare let fnParamExpressionLetVariableOk: (cb?: () => void) => number; +export declare let fnParamArrowLetVariableOk: (cb?: () => void) => string; +export declare var fnParamExpressionVarVariableOk: (cb?: () => void) => number; +export declare var fnParamArrowVarVariableOk: (cb?: () => void) => string; +export declare const fnParamExpressionConstVariableInternal: (cb?: () => void) => number; +export declare const fnParamArrowConstVariableInternal: (cb?: () => number) => string; +export declare let fnParamExpressionLetVariableInternal: (cb?: () => void) => number; +export declare let fnParamArrowLetVariableInternal: (cb?: () => number) => string; +export declare var fnParamExpressionVarVariableInternal: (cb?: () => void) => number; +export declare var fnParamArrowVarVariableInternal: (cb?: () => number) => string; +export declare class FnParamsExportedClass { + #private; + fnExpression: (cb?: () => void) => number; + fnArrow: (cb?: () => void) => string; + protected fnExpressionProtected: (cb?: () => void) => number; + protected fnArrowProtected: (cb?: () => void) => string; + static fnStaticExpression: (cb?: () => void) => number; + static fnStaticArrow: (cb?: () => void) => string; + protected static fnStaticExpressionProtected: (cb?: () => void) => number; + protected static fnStaticArrowProtected: (cb?: () => void) => string; + fnExpressionMethodHasReturn: (cb?: () => void) => number; + fnArrowMethodHasReturn: (cb?: () => void) => string; + protected fnExpressionProtectedMethodHasReturn: (cb?: () => void) => number; + protected fnArrowProtectedMethodHasReturn: (cb?: () => void) => string; + static fnStaticExpressionMethodHasReturn: (cb?: () => void) => number; + static fnStaticArrowMethodHasReturn: (cb?: () => void) => string; + protected static fnStaticExpressionProtectedMethodHasReturn: (cb?: () => void) => number; + protected static fnStaticArrowProtectedMethodHasReturn: (cb?: () => void) => string; + fnExpressionOnlyOnParam: (cb?: () => void) => number; + fnArrowOnlyOnParam: (cb?: () => void) => string; + protected fnExpressionProtectedOnlyOnParam: (cb?: () => void) => number; + protected fnArrowProtectedOnlyOnParam: (cb?: () => void) => string; + static fnStaticExpressionOnlyOnParam: (cb?: () => void) => number; + static fnStaticArrowOnlyOnParam: (cb?: () => void) => string; + protected static fnStaticExpressionProtectedOnlyOnParam: (cb?: () => void) => number; + protected static fnStaticArrowProtectedOnlyOnParam: (cb?: () => void) => string; + fnExpressionOk: (cb?: () => void) => number; + fnArrowOK: (cb?: () => void) => string; + protected fnExpressionProtectedOk: (cb?: () => void) => number; + protected fnArrowProtectedOK: (cb?: () => void) => string; + static fnStaticExpressionOk: (cb?: () => void) => number; + static fnStaticArrowOk: (cb?: () => void) => string; + protected static fnStaticExpressionProtectedOk: (cb?: () => void) => number; + protected static fnStaticArrowProtectedOk: (cb?: () => void) => string; + private fnExpressionPrivate; + private fnArrowPrivate; + private static fnStaticExpressionPrivate; + private static fnStaticArrowPrivate; +} +export {}; diff --git a/tests/baselines/reference/isolatedDeclarationLazySymbols.errors.txt b/tests/baselines/reference/isolatedDeclarationLazySymbols.errors.txt index bb46d672d1099..8271eda0ca3e4 100644 --- a/tests/baselines/reference/isolatedDeclarationLazySymbols.errors.txt +++ b/tests/baselines/reference/isolatedDeclarationLazySymbols.errors.txt @@ -1,14 +1,10 @@ -isolatedDeclarationLazySymbols.ts(1,17): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. isolatedDeclarationLazySymbols.ts(13,1): error TS9023: Assigning properties to functions without declaring them is not supported with --isolatedDeclarations. Add an explicit declaration for the properties assigned to this function. isolatedDeclarationLazySymbols.ts(16,5): error TS1166: A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type. isolatedDeclarationLazySymbols.ts(21,5): error TS9014: Computed properties must be number or string literals, variables or dotted expressions with --isolatedDeclarations. -==== isolatedDeclarationLazySymbols.ts (4 errors) ==== +==== isolatedDeclarationLazySymbols.ts (3 errors) ==== export function foo() { - ~~~ -!!! error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations. -!!! related TS9031 isolatedDeclarationLazySymbols.ts:1:17: Add a return type to the function declaration. } diff --git a/tests/cases/compiler/isolatedDeclarationErrorsClasses.ts b/tests/cases/compiler/isolatedDeclarationErrorsClasses.ts index f29915318bad6..9f69d768cd6d8 100644 --- a/tests/cases/compiler/isolatedDeclarationErrorsClasses.ts +++ b/tests/cases/compiler/isolatedDeclarationErrorsClasses.ts @@ -7,8 +7,12 @@ export class Cls { field = 1 + 1; - method() {} + method() { return console.log() } + methodImplicitVoid() { + if (Math.random() > 0.5) console.log() + else console.log() + } methodOk(): void {} methodParams(p): void {} @@ -40,7 +44,7 @@ export class C { // Should not be reported as an isolated declaration error [missing] = 1; - + [noAnnotationLiteralName](): void { } [noParamAnnotationLiteralName](v: string): void { }