Allow some per file compiler options

src/compiler/binder.ts

@@ -285,7 +285,7 @@ namespace ts {
         return bindSourceFile;
 
         function bindInStrictMode(file: SourceFile, opts: CompilerOptions): boolean {
-            if (getStrictOptionValue(opts, "alwaysStrict") && !file.isDeclarationFile) {
+            if (getStrictOptionValue(file, opts, "alwaysStrict") && !file.isDeclarationFile) {
                 // bind in strict mode source files with alwaysStrict option
                 return true;
             }
@@ -1351,7 +1351,7 @@ namespace ts {
                 const clause = clauses[i];
                 bind(clause);
                 fallthroughFlow = currentFlow;
-                if (!(currentFlow.flags & FlowFlags.Unreachable) && i !== clauses.length - 1 && options.noFallthroughCasesInSwitch) {
+                if (!(currentFlow.flags & FlowFlags.Unreachable) && i !== clauses.length - 1 && getFileLocalCompilerOption(file, options, "noFallthroughCasesInSwitch")) {
                     clause.fallthroughFlowNode = currentFlow;
                 }
             }

src/compiler/core.ts

@@ -2121,7 +2121,7 @@ namespace ts {
      *        (0.4 allows 1 substitution/transposition for every 5 characters,
      *         and 1 insertion/deletion at 3 characters)
      */
-    export function getSpellingSuggestion<T>(name: string, candidates: T[], getName: (candidate: T) => string | undefined): T | undefined {
+    export function getSpellingSuggestion<T>(name: string, candidates: readonly T[], getName: (candidate: T) => string | undefined): T | undefined {
         const maximumLengthDifference = Math.max(2, Math.floor(name.length * 0.34));
         let bestDistance = Math.floor(name.length * 0.4) + 1; // If the best result is worse than this, don't bother.
         let bestCandidate: T | undefined;
@@ -2530,4 +2530,8 @@ namespace ts {
         }
         return s.slice(0, end + 1);
     }
+
+    export function is<T>(): <U extends T>(arg: U) => U {
+        return identity;
+    }
 }

src/compiler/diagnosticMessages.json

@@ -908,6 +908,11 @@
         "code": 1276
     },
 
+    "Duplicate local compiler option '{0}'.": {
+        "category": "Error",
+        "code": 1280
+    },
+
     "'with' statements are not allowed in an async function block.": {
         "category": "Error",
         "code": 1300

src/compiler/parser.ts

@@ -9713,13 +9713,15 @@ namespace ts {
     export interface PragmaContext {
         languageVersion: ScriptTarget;
         pragmas?: PragmaMap;
+        localOptions?: CompilerOptions;
         checkJsDirective?: CheckJsDirective;
         referencedFiles: FileReference[];
         typeReferenceDirectives: FileReference[];
         libReferenceDirectives: FileReference[];
         amdDependencies: AmdDependency[];
         hasNoDefaultLib?: boolean;
         moduleName?: string;
+
     }
 
     function parseResolutionMode(mode: string | undefined, pos: number, end: number, reportDiagnostic: PragmaDiagnosticReporter): ModuleKind.ESNext | ModuleKind.CommonJS | undefined {
@@ -9836,12 +9838,65 @@ namespace ts {
                     });
                     break;
                 }
+                case "ts-strict":
+                case "ts-noimplicitany":
+                case "ts-strictnullchecks":
+                case "ts-strictfunctiontypes":
+                case "ts-strictbindcallapply":
+                case "ts-noimplicitthis":
+                case "ts-strictpropertyinitialization":
+                case "ts-useunknownincatchvariables":
+                case "ts-alwaysstrict":
+                case "ts-nounusedlocals":
+                case "ts-nounusedparameters":
+                case "ts-exactoptionalpropertytypes":
+                case "ts-nopropertyaccessfromindexsignature":
+                case "ts-noimplicitreturns":
+                case "ts-nofallthroughcasesinswitch":
+                case "ts-nouncheckedindexedaccess":
+                case "ts-noimplicitoverride": {
+                    const optName = key.slice(3);
+                    const opt = find(optionsAllowedAsPragmaOption, o => o.name.toLowerCase() === optName)!;
+                    const entry = (isArray(entryOrList) ? last(entryOrList) : entryOrList);
+                    const unparsedValue = (entry.arguments as PragmaArgumentType<`ts-${Lowercase<FileLocalOptionName>}`>).value;
+                    let parsedValue: OptionsBase[string];
+                    const errors: Diagnostic[] = [];
+                    if (!unparsedValue || !trimString(unparsedValue)) {
+                        parsedValue = true;
+                    }
+                    else {
+                        const optContainer: OptionsBase = {};
+                        const newIdx = parseOptionValue([unparsedValue], 0, /*diagnostics*/ undefined, opt, optContainer, errors);
+                        parsedValue = optContainer[opt.name];
+                        if (newIdx === 0) {
+                            // argument was not consumed, issue an error
+                            errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, optName, opt.type));
+                        }
+                    }
+                    if (unparsedValue === undefined && opt.type !== "boolean") {
+                        errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_expects_an_argument, optName));
+                    }
+                    for (const err of errors) {
+                        reportDiagnostic(entry.range.pos, entry.range.end - entry.range.pos, {
+                            category: err.category,
+                            code: err.code,
+                            message: err.messageText as string,
+                            reportsDeprecated: err.reportsDeprecated,
+                            reportsUnnecessary: err.reportsUnnecessary,
+                            key: err.messageText as string
+                        });
+                    }
+                    if (!length(errors)) {
+                        (context.localOptions ??= {})[opt.name as string] = parsedValue;
+                    }
+                    break;
+                }
                 case "jsx":
                 case "jsxfrag":
                 case "jsximportsource":
                 case "jsxruntime":
                     return; // Accessed directly
-                default: Debug.fail("Unhandled pragma kind"); // Can this be made into an assertNever in the future?
+                default: Debug.assertNever(key, `Unhandled pragma kind: ${key}`);
             }
         });
     }

src/compiler/program.ts

@@ -3288,7 +3288,7 @@ namespace ts {
                     // Don't add the file if it has a bad extension (e.g. 'tsx' if we don't have '--allowJs')
                     // This may still end up being an untyped module -- the file won't be included but imports will be allowed.
                     const shouldAddFile = resolvedFileName
-                        && !getResolutionDiagnostic(optionsForFile, resolution)
+                        && !getResolutionDiagnostic(file, optionsForFile, resolution)
                         && !optionsForFile.noResolve
                         && index < file.imports.length
                         && !elideImport
@@ -3390,10 +3390,10 @@ namespace ts {
         }
 
         function verifyCompilerOptions() {
-            if (options.strictPropertyInitialization && !getStrictOptionValue(options, "strictNullChecks")) {
+            if (options.strictPropertyInitialization && !getStrictOptionValue(/*file*/ undefined, options, "strictNullChecks")) {
                 createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "strictPropertyInitialization", "strictNullChecks");
             }
-            if (options.exactOptionalPropertyTypes && !getStrictOptionValue(options, "strictNullChecks")) {
+            if (options.exactOptionalPropertyTypes && !getStrictOptionValue(/*file*/ undefined, options, "strictNullChecks")) {
                 createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "exactOptionalPropertyTypes", "strictNullChecks");
             }
 
@@ -3522,7 +3522,7 @@ namespace ts {
                 createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "lib", "noLib");
             }
 
-            if (options.noImplicitUseStrict && getStrictOptionValue(options, "alwaysStrict")) {
+            if (options.noImplicitUseStrict && getStrictOptionValue(/*file*/ undefined, options, "alwaysStrict")) {
                 createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "noImplicitUseStrict", "alwaysStrict");
             }
 
@@ -3669,6 +3669,18 @@ namespace ts {
                 });
             }
 
+            for (const file of files) {
+                const entries = file.pragmas.entries();
+                for (let result = entries.next(); !result.done; result = entries.next()) {
+                    const [key, value] = result.value;
+                    if (startsWith(key, "ts-") && key !== "ts-check" && key !== "ts-nocheck" && isArray(value)) {
+                        for (const elem of value) {
+                            programDiagnostics.add(createDiagnosticForRange(file, elem.range, Diagnostics.Duplicate_local_compiler_option_0, key.slice(3)));
+                        }
+                    }
+                }
+            }
+
             // Verify that all the emit files are unique and don't overwrite input files
             function verifyEmitFilePath(emitFileName: string | undefined, emitFilesSeen: Set<string>) {
                 if (emitFileName) {
@@ -4323,7 +4335,7 @@ namespace ts {
      * The DiagnosticMessage's parameters are the imported module name, and the filename it resolved to.
      * This returns a diagnostic even if the module will be an untyped module.
      */
-    export function getResolutionDiagnostic(options: CompilerOptions, { extension }: ResolvedModuleFull): DiagnosticMessage | undefined {
+    export function getResolutionDiagnostic(file: SourceFile, options: CompilerOptions, { extension }: ResolvedModuleFull): DiagnosticMessage | undefined {
         switch (extension) {
             case Extension.Ts:
             case Extension.Dts:
@@ -4343,7 +4355,7 @@ namespace ts {
             return options.jsx ? undefined : Diagnostics.Module_0_was_resolved_to_1_but_jsx_is_not_set;
         }
         function needAllowJs() {
-            return getAllowJSCompilerOption(options) || !getStrictOptionValue(options, "noImplicitAny") ? undefined : Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type;
+            return getAllowJSCompilerOption(options) || !getStrictOptionValue(file, options, "noImplicitAny") ? undefined : Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type;
         }
         function needResolveJsonModule() {
             return options.resolveJsonModule ? undefined : Diagnostics.Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used;

src/compiler/transformers/module/module.ts

@@ -93,7 +93,7 @@ namespace ts {
             startLexicalEnvironment();
 
             const statements: Statement[] = [];
-            const ensureUseStrict = getStrictOptionValue(compilerOptions, "alwaysStrict") || (!compilerOptions.noImplicitUseStrict && isExternalModule(currentSourceFile));
+            const ensureUseStrict = getStrictOptionValue(node, compilerOptions, "alwaysStrict") || (!compilerOptions.noImplicitUseStrict && isExternalModule(currentSourceFile));
             const statementOffset = factory.copyPrologue(node.statements, statements, ensureUseStrict && !isJsonSourceFile(node), topLevelVisitor);
 
             if (shouldEmitUnderscoreUnderscoreESModule()) {

src/compiler/transformers/module/system.ts

@@ -222,7 +222,7 @@ namespace ts {
             startLexicalEnvironment();
 
             // Add any prologue directives.
-            const ensureUseStrict = getStrictOptionValue(compilerOptions, "alwaysStrict") || (!compilerOptions.noImplicitUseStrict && isExternalModule(currentSourceFile));
+            const ensureUseStrict = getStrictOptionValue(node, compilerOptions, "alwaysStrict") || (!compilerOptions.noImplicitUseStrict && isExternalModule(currentSourceFile));
             const statementOffset = factory.copyPrologue(node.statements, statements, ensureUseStrict, topLevelVisitor);
 
             // var __moduleName = context_1 && context_1.id;

src/compiler/transformers/ts.ts

@@ -577,7 +577,7 @@ namespace ts {
         }
 
         function visitSourceFile(node: SourceFile) {
-            const alwaysStrict = getStrictOptionValue(compilerOptions, "alwaysStrict") &&
+            const alwaysStrict = getStrictOptionValue(node, compilerOptions, "alwaysStrict") &&
                 !(isExternalModule(node) && moduleKind >= ModuleKind.ES2015) &&
                 !isJsonSourceFile(node);
 

src/compiler/transformers/typeSerializer.ts

@@ -63,7 +63,6 @@ namespace ts {
         const resolver = context.getEmitResolver();
         const compilerOptions = context.getCompilerOptions();
         const languageVersion = getEmitScriptTarget(compilerOptions);
-        const strictNullChecks = getStrictOptionValue(compilerOptions, "strictNullChecks");
 
         let currentLexicalScope: SourceFile | CaseBlock | ModuleBlock | Block;
         let currentNameScope: ClassLikeDeclaration | undefined;
@@ -344,7 +343,7 @@ namespace ts {
                     return factory.createIdentifier("Object"); // Reduce to `any` in a union or intersection
                 }
 
-                if (!strictNullChecks && ((isLiteralTypeNode(typeNode) && typeNode.literal.kind === SyntaxKind.NullKeyword) || typeNode.kind === SyntaxKind.UndefinedKeyword)) {
+                if (!getStrictOptionValue(getSourceFileOfNode(currentLexicalScope), compilerOptions, "strictNullChecks") && ((isLiteralTypeNode(typeNode) && typeNode.literal.kind === SyntaxKind.NullKeyword) || typeNode.kind === SyntaxKind.UndefinedKeyword)) {
                     continue; // Elide null and undefined from unions for metadata, just like what we did prior to the implementation of strict null checks
                 }
 

src/compiler/tsbuildPublic.ts

@@ -188,7 +188,7 @@ namespace ts {
     function getCompilerOptionsOfBuildOptions(buildOptions: BuildOptions): CompilerOptions {
         const result = {} as CompilerOptions;
         commonOptionsWithBuild.forEach(option => {
-            if (hasProperty(buildOptions, option.name)) result[option.name] = buildOptions[option.name];
+            if (hasProperty(buildOptions, option.name)) result[option.name as string] = buildOptions[option.name];
         });
         return result;
     }