Lint: Allow omitting return type in callback arrow functions (AssemblyScript#874)

emillaine · dcodeIO · commit 228afead3762 · 2019-09-29T19:13:43.000+02:00
diff --git a/NOTICE b/NOTICE
@@ -15,6 +15,7 @@ under the licensing terms detailed in LICENSE:
 * Aaron Turner <aaron@aaronthedev.com>
 * Willem Wyndham <willem@cs.umd.edu>
 * Bowen Wang <bowen@nearprotocol.com>
+* Emil Laine <laine.emil@gmail.com>
 
 Portions of this software are derived from third-party works licensed under
 the following terms:
diff --git a/README.md b/README.md
@@ -55,10 +55,10 @@ $> git clone https://github.com/AssemblyScript/assemblyscript.git
 $> cd assemblyscript
 $> npm install
 $> npm link
-$> npm clean
+$> npm run clean
 ```
 
-Note that a fresh clone of the compiler will use the distribution files in `dist/`, but after an `npm clean` it will run [the sources](./src) directly through ts-node, which is useful in development. This condition can also be checked by running `asc -v` (it is running the sources if it states `-dev`). Also please see our [contribution guidelines](./CONTRIBUTING.md) before making your first pull request.
+Note that a fresh clone of the compiler will use the distribution files in `dist/`, but after an `npm run clean` it will run [the sources](./src) directly through ts-node, which is useful in development. This condition can also be checked by running `asc -v` (it is running the sources if it states `-dev`). Also please see our [contribution guidelines](./CONTRIBUTING.md) before making your first pull request.
 
 Building
 --------
diff --git a/lib/lint/formatters/asFormatter.js b/lib/lint/formatters/asFormatter.js
@@ -41,10 +41,10 @@ class Formatter extends abstractFormatter_1.AbstractFormatter {
         });
     }
 }
+exports.Formatter = Formatter;
 Formatter.metadata = {
     formatterName: "as",
     description: "AssemblyScript's TSLint formatter.",
     sample: "Similar to ASC's output.",
     consumer: "human",
 };
-exports.Formatter = Formatter;
diff --git a/lib/lint/rules/asTypesRule.js b/lib/lint/rules/asTypesRule.js
@@ -7,9 +7,10 @@ class Rule extends Lint.Rules.AbstractRule {
         return this.applyWithWalker(new DiagnosticsWalker(sourceFile, this.getOptions()));
     }
 }
+exports.Rule = Rule;
 Rule.MISSING_TYPE_OR_INITIALIZER = "Missing type or initializer.";
 Rule.MISSING_RETURN_TYPE = "Missing return type.";
-exports.Rule = Rule;
+Rule.UNNECESSARY_RETURN_TYPE = "Unnecessary return type.";
 class DiagnosticsWalker extends Lint.RuleWalker {
     visitVariableDeclaration(node) {
         var list = node.parent;
@@ -39,7 +40,12 @@ class DiagnosticsWalker extends Lint.RuleWalker {
         super.visitFunctionDeclaration(node);
     }
     visitArrowFunction(node) {
-        this.checkFunctionReturnType(node);
+        if (requiresReturnType(node)) {
+            this.checkFunctionReturnType(node);
+        }
+        else if (node.type) {
+            this.addFailureAtNode(node.type, Rule.UNNECESSARY_RETURN_TYPE);
+        }
         super.visitArrowFunction(node);
     }
     visitMethodDeclaration(node) {
@@ -56,3 +62,10 @@ class DiagnosticsWalker extends Lint.RuleWalker {
         }
     }
 }
+function requiresReturnType(node) {
+    if (ts.isCallExpression(node.parent) && ts.isIdentifier(node.parent.expression)
+        && ["lengthof", "nameof"].includes(node.parent.expression.text)) {
+        return true;
+    }
+    return !ts.isCallLikeExpression(node.parent);
+}
diff --git a/lib/lint/rules/asVariablesRule.js b/lib/lint/rules/asVariablesRule.js
@@ -7,9 +7,9 @@ class Rule extends Lint.Rules.AbstractRule {
         return this.applyWithWalker(new VariablesWalker(sourceFile, this.getOptions()));
     }
 }
+exports.Rule = Rule;
 Rule.TOP_LEVEL_VAR = "Top-level variable should be 'var' (distinct local or global).";
 Rule.BLOCK_LEVEL_LET = "Block-level variable should be 'let' (shared local).";
-exports.Rule = Rule;
 class VariablesWalker extends Lint.RuleWalker {
     visitVariableDeclarationList(node) {
         if (tsutils_1.isVariableStatement(node.parent)) {
diff --git a/lib/lint/rules/internal/asInternalCaseRule.js b/lib/lint/rules/internal/asInternalCaseRule.js
@@ -8,8 +8,8 @@ class Rule extends Lint.Rules.AbstractRule {
         return this.applyWithWalker(new CaseWalker(sourceFile, this.getOptions()));
     }
 }
-Rule.NOT_BRACED = "Multi-line case clauses should be braced.";
 exports.Rule = Rule;
+Rule.NOT_BRACED = "Multi-line case clauses should be braced.";
 class CaseWalker extends Lint.RuleWalker {
     visitDefaultClause(node) {
         this.checkDefaultOrCaseClause(node);
diff --git a/lib/lint/rules/internal/asInternalDiagnosticsRule.js b/lib/lint/rules/internal/asInternalDiagnosticsRule.js
@@ -8,8 +8,8 @@ class Rule extends Lint.Rules.AbstractRule {
         return this.applyWithWalker(new DiagnosticsWalker(sourceFile, this.getOptions()));
     }
 }
-Rule.NOT_ON_SEPARATE_LINE = "Diagnostic message not on a separate line.";
 exports.Rule = Rule;
+Rule.NOT_ON_SEPARATE_LINE = "Diagnostic message not on a separate line.";
 class DiagnosticsWalker extends Lint.RuleWalker {
     visitPropertyAccessExpression(node) {
         if (node.expression.kind === ts.SyntaxKind.Identifier) {
diff --git a/lib/lint/src/rules/asTypesRule.ts b/lib/lint/src/rules/asTypesRule.ts
@@ -5,6 +5,7 @@ export class Rule extends Lint.Rules.AbstractRule {
 
   static MISSING_TYPE_OR_INITIALIZER = "Missing type or initializer.";
   static MISSING_RETURN_TYPE = "Missing return type.";
+  static UNNECESSARY_RETURN_TYPE = "Unnecessary return type.";
 
   apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
     return this.applyWithWalker(new DiagnosticsWalker(sourceFile, this.getOptions()));
@@ -46,7 +47,11 @@ class DiagnosticsWalker extends Lint.RuleWalker {
   }
 
   visitArrowFunction(node: ts.ArrowFunction) {
-    this.checkFunctionReturnType(node);
+    if (requiresReturnType(node)) {
+      this.checkFunctionReturnType(node);
+    } else if (node.type) {
+      this.addFailureAtNode(node.type, Rule.UNNECESSARY_RETURN_TYPE);
+    }
     super.visitArrowFunction(node);
   }
 
@@ -66,3 +71,11 @@ class DiagnosticsWalker extends Lint.RuleWalker {
     }
   }
 }
+
+function requiresReturnType(node: ts.ArrowFunction): boolean {
+  if (ts.isCallExpression(node.parent) && ts.isIdentifier(node.parent.expression)
+    && ["lengthof", "nameof"].includes(node.parent.expression.text)) {
+    return true;
+  }
+  return !ts.isCallLikeExpression(node.parent);
+}
diff --git a/tests/compiler/std/array.ts b/tests/compiler/std/array.ts
@@ -396,25 +396,25 @@ var i: i32;
   arr[2] = 2;
   arr[3] = 3;
 
-  i = arr.findIndex((value: i32, index: i32, array: Array<i32>): bool => value == 0);
+  i = arr.findIndex((value: i32, index: i32, array: Array<i32>) => value == 0);
 
   assert(i == 0);
 
-  i = arr.findIndex((value: i32, index: i32, array: Array<i32>): bool => value == 1);
+  i = arr.findIndex((value: i32, index: i32, array: Array<i32>) => value == 1);
   assert(i == 1);
 
-  i = arr.findIndex((value: i32, index: i32, array: Array<i32>): bool => value == 100);
+  i = arr.findIndex((value: i32, index: i32, array: Array<i32>) => value == 100);
   assert(i == -1);
 
   // Test side effect push
-  i = arr.findIndex((value: i32, index: i32, array: Array<i32>): bool => {
+  i = arr.findIndex((value: i32, index: i32, array: Array<i32>) => {
     array.push(100); // push side effect should not affect this method by spec
     return value == 100;
   });
   // array should be changed, but this method result should be calculated for old array length
   assert(i == -1);
   assert(arr.length == 8);
-  i = arr.findIndex((value: i32, index: i32, array: Array<i32>): bool => value == 100);
+  i = arr.findIndex((value: i32, index: i32, array: Array<i32>) => value == 100);
   assert(i != -1);
 
   arr.pop();
@@ -423,7 +423,7 @@ var i: i32;
   arr.pop();
 
   // Test side effect pop
-  i = arr.findIndex((value: i32, index: i32, array: Array<i32>): bool => {
+  i = arr.findIndex((value: i32, index: i32, array: Array<i32>) => {
     array.pop(); // popped items shouldn't be looked up, and we shouldn't go out of bounds
     return value == 100;
   });
@@ -438,21 +438,21 @@ var i: i32;
 // Array#every /////////////////////////////////////////////////////////////////////////////////////
 
 {
-  let every = arr.every((value: i32, index: i32, array: Array<i32>): bool => value >= 0);
+  let every = arr.every((value: i32, index: i32, array: Array<i32>) => value >= 0);
   assert(every == true);
 
-  every = arr.every((value: i32, index: i32, array: Array<i32>): bool => value <= 0);
+  every = arr.every((value: i32, index: i32, array: Array<i32>) => value <= 0);
   assert(every == false);
 
   // Test side effect push
-  every = arr.every((value: i32, index: i32, array: Array<i32>): bool => {
+  every = arr.every((value: i32, index: i32, array: Array<i32>) => {
     array.push(100); // push side effect should not affect this method by spec
     return value < 10;
   });
   // array should be changed, but this method result should be calculated for old array length
   assert(every == true);
   assert(arr.length == 8);
-  every = arr.every((value: i32, index: i32, array: Array<i32>): bool => value < 10);
+  every = arr.every((value: i32, index: i32, array: Array<i32>) => value < 10);
   assert(every == false);
 
   arr.pop();
@@ -461,7 +461,7 @@ var i: i32;
   arr.pop();
 
   // Test side effect pop
-  every = arr.every((value: i32, index: i32, array: Array<i32>): bool => {
+  every = arr.every((value: i32, index: i32, array: Array<i32>) => {
     array.pop(); //poped items shouldn't be looked up, and we shouldn't go out of bounds
     return value < 3;
   });
@@ -476,21 +476,21 @@ var i: i32;
 // Array#some //////////////////////////////////////////////////////////////////////////////////////
 
 {
-  let some = arr.some((value: i32, index: i32, array: Array<i32>): bool => value >= 3);
+  let some = arr.some((value: i32, index: i32, array: Array<i32>) => value >= 3);
   assert(some == true);
 
-  some = arr.some((value: i32, index: i32, array: Array<i32>): bool => value <= -1);
+  some = arr.some((value: i32, index: i32, array: Array<i32>) => value <= -1);
   assert(some == false);
 
   // Test side effect push
-  some = arr.some((value: i32, index: i32, array: Array<i32>): bool => {
+  some = arr.some((value: i32, index: i32, array: Array<i32>) => {
     array.push(100); // push side effect should not affect this method by spec
     return value > 10;
   });
   // array should be changed, but this method result should be calculated for old array length
   assert(some == false);
   assert(arr.length == 8);
-  some = arr.some((value: i32, index: i32, array: Array<i32>): bool => value > 10);
+  some = arr.some((value: i32, index: i32, array: Array<i32>) => value > 10);
   assert(some == true);
 
   arr.pop();
@@ -499,7 +499,7 @@ var i: i32;
   arr.pop();
 
   // Test side effect pop
-  some = arr.some((value: i32, index: i32, array: Array<i32>): bool => {
+  some = arr.some((value: i32, index: i32, array: Array<i32>) => {
     array.pop(); // poped items shouldn't be looked up, and we shouldn't go out of bounds
     return value > 3;
   });
@@ -515,20 +515,20 @@ var i: i32;
 
 {
   i = 0;
-  arr.forEach((value: i32, index: i32, array: Array<i32>): void => { i += value; });
+  arr.forEach((value: i32, index: i32, array: Array<i32>) => { i += value; });
   assert(i == 6);
 
   // Test side effect push
   i = 0;
-  arr.forEach((value: i32, index: i32, array: Array<i32>): void => {
+  arr.forEach((value: i32, index: i32, array: Array<i32>) => {
     array.push(100); //push side effect should not affect this method by spec
     i += value;
   });
   // array should be changed, but this method result should be calculated for old array length
   assert(i == 6);
   assert(arr.length == 8);
   i = 0;
-  arr.forEach((value: i32, index: i32, array: Array<i32>): void => { i += value; });
+  arr.forEach((value: i32, index: i32, array: Array<i32>) => { i += value; });
   assert(i == 406);
 
   arr.pop();
@@ -538,7 +538,7 @@ var i: i32;
 
   // Test side effect pop
   i = 0;
-  arr.forEach((value: i32, index: i32, array: Array<i32>): void => {
+  arr.forEach((value: i32, index: i32, array: Array<i32>) => {
     array.pop(); //poped items shouldn't be looked up, and we shouldn't go out of bounds
     i += value;
   });
@@ -550,7 +550,7 @@ var i: i32;
   arr.push(3);
 
   // Test rehash action effec
-  arr.forEach((value: i32, index: i32, array: Array<i32>): void => {
+  arr.forEach((value: i32, index: i32, array: Array<i32>) => {
     if (index == 0) {
       for (let i = 0; i < 4; i++) {
         array.pop();
@@ -582,13 +582,13 @@ var i: i32;
 // Array#map ///////////////////////////////////////////////////////////////////////////////////////
 
 {
-  let newArr: f32[] = arr.map<f32>((value: i32, index: i32, array: Array<i32>): f32 => <f32>value);
+  let newArr: f32[] = arr.map<f32>((value: i32, index: i32, array: Array<i32>) => <f32>value);
   assert(newArr.length == 4);
   assert(newArr[0] == <f32>arr[0]);
 
   // Test side effect push
   i = 0;
-  arr.map<i32>((value: i32, index: i32, array: Array<i32>): i32 => {
+  arr.map<i32>((value: i32, index: i32, array: Array<i32>) => {
     array.push(100); //push side effect should not affect this method by spec
     i += value;
     return value;
@@ -597,7 +597,7 @@ var i: i32;
   assert(arr.length == 8);
 
   i = 0;
-  arr.map<i32>((value: i32, index: i32, array: Array<i32>): i32 => {
+  arr.map<i32>((value: i32, index: i32, array: Array<i32>) => {
     i += value;
     return value;
   });
@@ -610,7 +610,7 @@ var i: i32;
 
   // Test side effect pop
   i = 0;
-  arr.map<i32>((value: i32, index: i32, array: Array<i32>): i32 => {
+  arr.map<i32>((value: i32, index: i32, array: Array<i32>) => {
     array.pop(); //poped items shouldn't be looked up, and we shouldn't go out of bounds
     i += value;
     return value;
@@ -626,12 +626,12 @@ var i: i32;
 // Array#filter ////////////////////////////////////////////////////////////////////////////////////
 
 {
-  let filteredArr: i32[] = arr.filter((value: i32, index: i32, array: Array<i32>): bool => value >= 2);
+  let filteredArr: i32[] = arr.filter((value: i32, index: i32, array: Array<i32>) => value >= 2);
   assert(filteredArr.length == 2);
 
   // Test side effect push
   i = 0;
-  arr.filter((value: i32, index: i32, array: Array<i32>): bool => {
+  arr.filter((value: i32, index: i32, array: Array<i32>) => {
     array.push(100); //push side effect should not affect this method by spec
     i += value;
     return value >= 2;
@@ -640,7 +640,7 @@ var i: i32;
   assert(arr.length == 8);
 
   i = 0;
-  arr.filter((value: i32, index: i32, array: Array<i32>): bool => {
+  arr.filter((value: i32, index: i32, array: Array<i32>) => {
     i += value;
     return value >= 2;
   });
@@ -653,7 +653,7 @@ var i: i32;
 
   // Test side effect pop
   i = 0;
-  arr.filter((value: i32, index: i32, array: Array<i32>): bool => {
+  arr.filter((value: i32, index: i32, array: Array<i32>) => {
     array.pop(); //poped items shouldn't be looked up, and we shouldn't go out of bounds
     i += value;
     return value >= 2;
@@ -900,23 +900,23 @@ function assertSortedDefault<T>(arr: Array<T>): void {
   let randomized64  = createRandomOrderedArray(64);
   let randomized257 = createRandomOrderedArray(257);
 
-  assertSorted<i32>(randomized64, (a: i32, b: i32): i32 => a - b);
-  assertSorted<i32>(randomized64, (a: i32, b: i32): i32 => b - a);
+  assertSorted<i32>(randomized64, (a: i32, b: i32) => a - b);
+  assertSorted<i32>(randomized64, (a: i32, b: i32) => b - a);
 
-  assertSorted<i32>(randomized257, (a: i32, b: i32): i32 => a - b);
-  assertSorted<i32>(randomized257, (a: i32, b: i32): i32 => b - a);
+  assertSorted<i32>(randomized257, (a: i32, b: i32) => a - b);
+  assertSorted<i32>(randomized257, (a: i32, b: i32) => b - a);
 }
 
 // Test sorting complex objects
 {
   let reversedNested512 = createReverseOrderedNestedArray(2);
-  assertSorted<i32[]>(reversedNested512, (a: i32[], b: i32[]): i32 => a[0] - b[0]);
+  assertSorted<i32[]>(reversedNested512, (a: i32[], b: i32[]) => a[0] - b[0]);
 }
 
 // Test sorting reference elements
 {
   let reversedElements512 = createReverseOrderedElementsArray(512);
-  assertSorted<Proxy<i32>>(reversedElements512, (a: Proxy<i32>, b: Proxy<i32>): i32 => a.x - b.x);
+  assertSorted<Proxy<i32>>(reversedElements512, (a: Proxy<i32>, b: Proxy<i32>) => a.x - b.x);
 }
 
 // Test sorting strings
diff --git a/tests/compiler/std/typedarray.ts b/tests/compiler/std/typedarray.ts

Original file line number	Diff line number	Diff line change
`@@ -41,10 +41,10 @@ class Formatter extends abstractFormatter_1.AbstractFormatter {`
`41`	`41`	`});`
`42`	`42`	`}`
`43`	`43`	`}`
	`44`	`+exports.Formatter = Formatter;`
`44`	`45`	`Formatter.metadata = {`
`45`	`46`	`formatterName: "as",`
`46`	`47`	`description: "AssemblyScript's TSLint formatter.",`
`47`	`48`	`sample: "Similar to ASC's output.",`
`48`	`49`	`consumer: "human",`
`49`	`50`	`};`
`50`		`-exports.Formatter = Formatter;`
Original file line number	Diff line number	Diff line change
`@@ -7,9 +7,10 @@ class Rule extends Lint.Rules.AbstractRule {`
`7`	`7`	`return this.applyWithWalker(new DiagnosticsWalker(sourceFile, this.getOptions()));`
`8`	`8`	`}`
`9`	`9`	`}`
	`10`	`+exports.Rule = Rule;`
`10`	`11`	`Rule.MISSING_TYPE_OR_INITIALIZER = "Missing type or initializer.";`
`11`	`12`	`Rule.MISSING_RETURN_TYPE = "Missing return type.";`
`12`		`-exports.Rule = Rule;`
	`13`	`+Rule.UNNECESSARY_RETURN_TYPE = "Unnecessary return type.";`
`13`	`14`	`class DiagnosticsWalker extends Lint.RuleWalker {`
`14`	`15`	`visitVariableDeclaration(node) {`
`15`	`16`	`var list = node.parent;`
`@@ -39,7 +40,12 @@ class DiagnosticsWalker extends Lint.RuleWalker {`
`39`	`40`	`super.visitFunctionDeclaration(node);`
`40`	`41`	`}`
`41`	`42`	`visitArrowFunction(node) {`
`42`		`- this.checkFunctionReturnType(node);`
	`43`	`+ if (requiresReturnType(node)) {`
	`44`	`+ this.checkFunctionReturnType(node);`
	`45`	`+ }`
	`46`	`+ else if (node.type) {`
	`47`	`+ this.addFailureAtNode(node.type, Rule.UNNECESSARY_RETURN_TYPE);`
	`48`	`+ }`
`43`	`49`	`super.visitArrowFunction(node);`
`44`	`50`	`}`
`45`	`51`	`visitMethodDeclaration(node) {`
`@@ -56,3 +62,10 @@ class DiagnosticsWalker extends Lint.RuleWalker {`
`56`	`62`	`}`
`57`	`63`	`}`
`58`	`64`	`}`
	`65`	`+function requiresReturnType(node) {`
	`66`	`+ if (ts.isCallExpression(node.parent) && ts.isIdentifier(node.parent.expression)`
	`67`	`+ && ["lengthof", "nameof"].includes(node.parent.expression.text)) {`
	`68`	`+ return true;`
	`69`	`+ }`
	`70`	`+ return !ts.isCallLikeExpression(node.parent);`
	`71`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -7,9 +7,9 @@ class Rule extends Lint.Rules.AbstractRule {`
`7`	`7`	`return this.applyWithWalker(new VariablesWalker(sourceFile, this.getOptions()));`
`8`	`8`	`}`
`9`	`9`	`}`
	`10`	`+exports.Rule = Rule;`
`10`	`11`	`Rule.TOP_LEVEL_VAR = "Top-level variable should be 'var' (distinct local or global).";`
`11`	`12`	`Rule.BLOCK_LEVEL_LET = "Block-level variable should be 'let' (shared local).";`
`12`		`-exports.Rule = Rule;`
`13`	`13`	`class VariablesWalker extends Lint.RuleWalker {`
`14`	`14`	`visitVariableDeclarationList(node) {`
`15`	`15`	`if (tsutils_1.isVariableStatement(node.parent)) {`
Original file line number	Diff line number	Diff line change
`@@ -8,8 +8,8 @@ class Rule extends Lint.Rules.AbstractRule {`
`8`	`8`	`return this.applyWithWalker(new CaseWalker(sourceFile, this.getOptions()));`
`9`	`9`	`}`
`10`	`10`	`}`
`11`		`-Rule.NOT_BRACED = "Multi-line case clauses should be braced.";`
`12`	`11`	`exports.Rule = Rule;`
	`12`	`+Rule.NOT_BRACED = "Multi-line case clauses should be braced.";`
`13`	`13`	`class CaseWalker extends Lint.RuleWalker {`
`14`	`14`	`visitDefaultClause(node) {`
`15`	`15`	`this.checkDefaultOrCaseClause(node);`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@ export class Rule extends Lint.Rules.AbstractRule {`
`5`	`5`
`6`	`6`	`static MISSING_TYPE_OR_INITIALIZER = "Missing type or initializer.";`
`7`	`7`	`static MISSING_RETURN_TYPE = "Missing return type.";`
	`8`	`+ static UNNECESSARY_RETURN_TYPE = "Unnecessary return type.";`
`8`	`9`
`9`	`10`	`apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {`
`10`	`11`	`return this.applyWithWalker(new DiagnosticsWalker(sourceFile, this.getOptions()));`
`@@ -46,7 +47,11 @@ class DiagnosticsWalker extends Lint.RuleWalker {`
`46`	`47`	`}`
`47`	`48`
`48`	`49`	`visitArrowFunction(node: ts.ArrowFunction) {`
`49`		`- this.checkFunctionReturnType(node);`
	`50`	`+ if (requiresReturnType(node)) {`
	`51`	`+ this.checkFunctionReturnType(node);`
	`52`	`+ } else if (node.type) {`
	`53`	`+ this.addFailureAtNode(node.type, Rule.UNNECESSARY_RETURN_TYPE);`
	`54`	`+ }`
`50`	`55`	`super.visitArrowFunction(node);`
`51`	`56`	`}`
`52`	`57`
`@@ -66,3 +71,11 @@ class DiagnosticsWalker extends Lint.RuleWalker {`
`66`	`71`	`}`
`67`	`72`	`}`
`68`	`73`	`}`
	`74`	`+`
	`75`	`+function requiresReturnType(node: ts.ArrowFunction): boolean {`
	`76`	`+ if (ts.isCallExpression(node.parent) && ts.isIdentifier(node.parent.expression)`
	`77`	`+ && ["lengthof", "nameof"].includes(node.parent.expression.text)) {`
	`78`	`+ return true;`
	`79`	`+ }`
	`80`	`+ return !ts.isCallLikeExpression(node.parent);`
	`81`	`+}`