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;
  }