Rename to language extensions / extensions

hazzard993 · hazzard993 · commit e0d3cf43aa14 · 2020-12-22T13:39:40.000+10:00
diff --git a/language-extensions/index.d.ts b/language-extensions/index.d.ts
diff --git a/package.json b/package.json
@@ -14,7 +14,7 @@
         "dist/**/*.js",
         "dist/**/*.lua",
         "dist/**/*.ts",
-        "helpers/**/*.ts"
+        "language-extensions/**/*.ts"
     ],
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
diff --git a/src/lualib/tsconfig.json b/src/lualib/tsconfig.json
@@ -3,7 +3,7 @@
         "outDir": "../../dist/lualib",
         "target": "esnext",
         "lib": ["esnext"],
-        "types": ["../../helpers"],
+        "types": ["../../language-extensions"],
         "skipLibCheck": true,
 
         "noUnusedLocals": true,
diff --git a/src/transformation/utils/language-extensions.ts b/src/transformation/utils/language-extensions.ts
@@ -1,28 +1,28 @@
 import * as ts from "typescript";
 import * as path from "path";
 
-export enum HelperKind {
+export enum ExtensionKind {
     MultiFunction = "MultiFunction",
     MultiType = "MultiType",
 }
 
-function isSourceFileFromHelpers(sourceFile: ts.SourceFile): boolean {
-    const helperDirectory = path.resolve(__dirname, "../../../helpers");
+function isSourceFileFromLanguageExtensions(sourceFile: ts.SourceFile): boolean {
+    const helperDirectory = path.resolve(__dirname, "../../../language-extensions");
     const sourceFileDirectory = path.dirname(path.normalize(sourceFile.fileName));
     return helperDirectory === sourceFileDirectory;
 }
 
-export function getHelperKind(declaration: ts.Declaration): HelperKind | undefined {
+export function getExtensionKind(declaration: ts.Declaration): ExtensionKind | undefined {
     const sourceFile = declaration.getSourceFile();
-    if (isSourceFileFromHelpers(sourceFile)) {
+    if (isSourceFileFromLanguageExtensions(sourceFile)) {
         if (ts.isFunctionDeclaration(declaration) && declaration?.name?.text === "$multi") {
-            return HelperKind.MultiFunction;
+            return ExtensionKind.MultiFunction;
         }
 
         if (ts.isTypeAliasDeclaration(declaration) && declaration.name.text === "MultiReturn") {
-            return HelperKind.MultiType;
+            return ExtensionKind.MultiType;
         }
 
-        throw new Error("Unknown helper kind");
+        throw new Error("Unknown extension kind");
     }
 }
diff --git a/src/transformation/visitors/call.ts b/src/transformation/visitors/call.ts
@@ -11,7 +11,7 @@ import { isValidLuaIdentifier } from "../utils/safe-names";
 import { isArrayType, isExpressionWithEvaluationEffect, isInDestructingAssignment } from "../utils/typescript";
 import { transformElementAccessArgument } from "./access";
 import { transformLuaTableCallExpression } from "./lua-table";
-import { returnsMultiType } from "./helpers/multi";
+import { returnsMultiType } from "./language-extensions/multi";
 
 export type PropertyCallExpression = ts.CallExpression & { expression: ts.PropertyAccessExpression };
 
diff --git a/src/transformation/visitors/expression-statement.ts b/src/transformation/visitors/expression-statement.ts
@@ -5,7 +5,7 @@ import { transformBinaryExpressionStatement } from "./binary-expression";
 import { transformDeleteExpressionStatement } from "./delete";
 import { transformLuaTableExpressionStatement } from "./lua-table";
 import { transformUnaryExpressionStatement } from "./unary-expression";
-import { transformMultiHelperDestructuringAssignmentStatement } from "./helpers/multi";
+import { transformMultiHelperDestructuringAssignmentStatement } from "./language-extensions/multi";
 
 export const transformExpressionStatement: FunctionVisitor<ts.ExpressionStatement> = (node, context) => {
     const multiResult = transformMultiHelperDestructuringAssignmentStatement(context, node);
diff --git a/src/transformation/visitors/identifier.ts b/src/transformation/visitors/identifier.ts
@@ -8,7 +8,7 @@ import { createExportedIdentifier, getSymbolExportScope } from "../utils/export"
 import { createSafeName, hasUnsafeIdentifierName } from "../utils/safe-names";
 import { getIdentifierSymbolId } from "../utils/symbols";
 import { findFirstNodeAbove } from "../utils/typescript";
-import { isMultiFunctionNode } from "./helpers/multi";
+import { isMultiFunctionNode } from "./language-extensions/multi";
 
 export function transformIdentifier(context: TransformationContext, identifier: ts.Identifier): lua.Identifier {
     if (isMultiFunctionNode(context, identifier)) {
diff --git a/src/transformation/visitors/language-extensions/multi.ts b/src/transformation/visitors/language-extensions/multi.ts
@@ -1,6 +1,6 @@
 import * as ts from "typescript";
 import * as lua from "../../../LuaAST";
-import * as helpers from "../../utils/helpers";
+import * as extensions from "../../utils/language-extensions";
 import { TransformationContext } from "../../context";
 import { transformAssignmentLeftHandSideExpression } from "../binary-expression/assignments";
 import { transformIdentifier } from "../identifier";
@@ -15,13 +15,13 @@ import {
     invalidMultiTypeToNonArrayLiteral,
     unsupportedMultiFunctionAssignment,
     invalidMultiFunctionUse,
-} from "../../../transformation/utils/diagnostics";
+} from "../../utils/diagnostics";
 
 const isMultiFunctionDeclaration = (declaration: ts.Declaration): boolean =>
-    helpers.getHelperKind(declaration) === helpers.HelperKind.MultiFunction;
+    extensions.getExtensionKind(declaration) === extensions.ExtensionKind.MultiFunction;
 
 const isMultiTypeDeclaration = (declaration: ts.Declaration): boolean =>
-    helpers.getHelperKind(declaration) === helpers.HelperKind.MultiType;
+    extensions.getExtensionKind(declaration) === extensions.ExtensionKind.MultiType;
 
 function isMultiFunction(context: TransformationContext, expression: ts.CallExpression): boolean {
     const type = context.checker.getTypeAtLocation(expression.expression);
diff --git a/src/transformation/visitors/literal.ts b/src/transformation/visitors/literal.ts
@@ -10,7 +10,7 @@ import { getSymbolIdOfSymbol, trackSymbolReference } from "../utils/symbols";
 import { isArrayType } from "../utils/typescript";
 import { transformFunctionLikeDeclaration } from "./function";
 import { flattenSpreadExpressions } from "./call";
-import { findMultiHelperAssignmentViolations } from "./helpers/multi";
+import { findMultiHelperAssignmentViolations } from "./language-extensions/multi";
 
 // TODO: Move to object-literal.ts?
 export function transformPropertyName(context: TransformationContext, node: ts.PropertyName): lua.Expression {
diff --git a/src/transformation/visitors/return.ts b/src/transformation/visitors/return.ts
@@ -6,7 +6,7 @@ import { validateAssignment } from "../utils/assignment-validation";
 import { createUnpackCall, wrapInTable } from "../utils/lua-ast";
 import { ScopeType, walkScopesUp } from "../utils/scope";
 import { isArrayType } from "../utils/typescript";
-import { transformMultiHelperReturnStatement } from "./helpers/multi";
+import { transformMultiHelperReturnStatement } from "./language-extensions/multi";
 
 export const transformReturnStatement: FunctionVisitor<ts.ReturnStatement> = (statement, context) => {
     // Bubble up explicit return flag and check if we're inside a try/catch block
diff --git a/src/transformation/visitors/variable-declaration.ts b/src/transformation/visitors/variable-declaration.ts
@@ -10,7 +10,7 @@ import { createLocalOrExportedOrGlobalDeclaration, createUnpackCall } from "../u
 import { LuaLibFeature, transformLuaLibFunction } from "../utils/lualib";
 import { transformIdentifier } from "./identifier";
 import { transformPropertyName } from "./literal";
-import { transformMultiHelperVariableDeclaration } from "./helpers/multi";
+import { transformMultiHelperVariableDeclaration } from "./language-extensions/multi";
 
 export function transformArrayBindingElement(
     context: TransformationContext,
diff --git a/src/transpilation/index.ts b/src/transpilation/index.ts
@@ -66,7 +66,7 @@ export function createVirtualProgram(input: Record<string, string>, options: Com
                 filePath = path.join(typeScriptDir, fileName);
             }
 
-            if (fileName.includes("helpers")) {
+            if (fileName.includes("language-extensions")) {
                 const dtsName = fileName.replace(/(\.d)?(\.ts)$/, ".d.ts");
                 filePath = path.resolve(dtsName);
             }
diff --git a/test/tsconfig.json b/test/tsconfig.json
@@ -14,6 +14,6 @@
         "transpile/directories",
         "transpile/outFile",
         "../src/lualib",
-        "../helpers"
+        "../language-extensions"
     ]
 }
diff --git a/test/unit/helpers/multi.spec.ts b/test/unit/helpers/multi.spec.ts
@@ -8,7 +8,7 @@ import {
 } from "../../../src/transformation/utils/diagnostics";
 
 const multiProjectOptions: tstl.CompilerOptions = {
-    types: [path.resolve(__dirname, "../../../helpers")],
+    types: [path.resolve(__dirname, "../../../language-extensions")],
 };
 
 test.each<[string, any]>([

Original file line number	Diff line number	Diff line change
`@@ -1,28 +1,28 @@`
`1`	`1`	`import * as ts from "typescript";`
`2`	`2`	`import * as path from "path";`
`3`	`3`
`4`		`-export enum HelperKind {`
	`4`	`+export enum ExtensionKind {`
`5`	`5`	`MultiFunction = "MultiFunction",`
`6`	`6`	`MultiType = "MultiType",`
`7`	`7`	`}`
`8`	`8`
`9`		`-function isSourceFileFromHelpers(sourceFile: ts.SourceFile): boolean {`
`10`		`- const helperDirectory = path.resolve(__dirname, "../../../helpers");`
	`9`	`+function isSourceFileFromLanguageExtensions(sourceFile: ts.SourceFile): boolean {`
	`10`	`+ const helperDirectory = path.resolve(__dirname, "../../../language-extensions");`
`11`	`11`	`const sourceFileDirectory = path.dirname(path.normalize(sourceFile.fileName));`
`12`	`12`	`return helperDirectory === sourceFileDirectory;`
`13`	`13`	`}`
`14`	`14`
`15`		`-export function getHelperKind(declaration: ts.Declaration): HelperKind \| undefined {`
	`15`	`+export function getExtensionKind(declaration: ts.Declaration): ExtensionKind \| undefined {`
`16`	`16`	`const sourceFile = declaration.getSourceFile();`
`17`		`- if (isSourceFileFromHelpers(sourceFile)) {`
	`17`	`+ if (isSourceFileFromLanguageExtensions(sourceFile)) {`
`18`	`18`	`if (ts.isFunctionDeclaration(declaration) && declaration?.name?.text === "$multi") {`
`19`		`- return HelperKind.MultiFunction;`
	`19`	`+ return ExtensionKind.MultiFunction;`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`if (ts.isTypeAliasDeclaration(declaration) && declaration.name.text === "MultiReturn") {`
`23`		`- return HelperKind.MultiType;`
	`23`	`+ return ExtensionKind.MultiType;`
`24`	`24`	`}`
`25`	`25`
`26`		`- throw new Error("Unknown helper kind");`
	`26`	`+ throw new Error("Unknown extension kind");`
`27`	`27`	`}`
`28`	`28`	`}`