hermes-estree 0.9.0 → 0.10.1

package/dist/generated/predicates.js

@@ -6,12 +6,19 @@
  *
  * 
  * @format
+ * @generated
+ */
+
+/*
+ * !!! GENERATED FILE !!!
+ *
+ * Any manual changes to this file will be overwritten. To regenerate run `yarn build`.
  */
 // lint directives to let us do some basic validation of generated files
 
 /* eslint no-undef: 'error', no-unused-vars: ['error', {vars: "local"}], no-redeclare: 'error' */
 
-/* global $NonMaybeType, $Partial, $ReadOnly, $ReadOnlyArray */
+/* global $NonMaybeType, Partial, $ReadOnly, $ReadOnlyArray */
 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
@@ -30,6 +37,7 @@ exports.isAsyncKeyword = isAsyncKeyword;
 exports.isAwaitExpression = isAwaitExpression;
 exports.isAwaitKeyword = isAwaitKeyword;
 exports.isBigIntLiteralTypeAnnotation = isBigIntLiteralTypeAnnotation;
+exports.isBigIntTypeAnnotation = isBigIntTypeAnnotation;
 exports.isBinaryExpression = isBinaryExpression;
 exports.isBitwiseANDEqualToken = isBitwiseANDEqualToken;
 exports.isBitwiseANDToken = isBitwiseANDToken;
@@ -313,6 +321,10 @@ function isBigIntLiteralTypeAnnotation(node) {
   return node.type === 'BigIntLiteralTypeAnnotation';
 }
 
+function isBigIntTypeAnnotation(node) {
+  return node.type === 'BigIntTypeAnnotation';
+}
+
 function isBinaryExpression(node) {
   return node.type === 'BinaryExpression';
 }
@@ -1218,47 +1230,47 @@ function isYieldToken(node) {
 }
 
 function isAsKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'as';
+  return node.type === 'Identifier' && node.name === 'as' || node.type === 'Keyword' && node.value === 'as';
 }
 
 function isAsyncKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'async';
+  return node.type === 'Identifier' && node.name === 'async' || node.type === 'Keyword' && node.value === 'async';
 }
 
 function isAwaitKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'await';
+  return node.type === 'Identifier' && node.name === 'await' || node.type === 'Keyword' && node.value === 'await';
 }
 
 function isDeclareKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'declare';
+  return node.type === 'Identifier' && node.name === 'declare' || node.type === 'Keyword' && node.value === 'declare';
 }
 
 function isFromKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'from';
+  return node.type === 'Identifier' && node.name === 'from' || node.type === 'Keyword' && node.value === 'from';
 }
 
 function isGetKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'get';
+  return node.type === 'Identifier' && node.name === 'get' || node.type === 'Keyword' && node.value === 'get';
 }
 
 function isLetKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'let';
+  return node.type === 'Identifier' && node.name === 'let' || node.type === 'Keyword' && node.value === 'let';
 }
 
 function isModuleKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'module';
+  return node.type === 'Identifier' && node.name === 'module' || node.type === 'Keyword' && node.value === 'module';
 }
 
 function isOfKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'of';
+  return node.type === 'Identifier' && node.name === 'of' || node.type === 'Keyword' && node.value === 'of';
 }
 
 function isSetKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'set';
+  return node.type === 'Identifier' && node.name === 'set' || node.type === 'Keyword' && node.value === 'set';
 }
 
 function isTypeKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'type';
+  return node.type === 'Identifier' && node.name === 'type' || node.type === 'Keyword' && node.value === 'type';
 }
 
 function isCommaToken(node) {

package/dist/generated/predicates.js.flow

@@ -6,11 +6,18 @@
  *
  * @flow strict-local
  * @format
+ * @generated
+ */
+
+/*
+ * !!! GENERATED FILE !!!
+ *
+ * Any manual changes to this file will be overwritten. To regenerate run `yarn build`.
  */
 
 // lint directives to let us do some basic validation of generated files
 /* eslint no-undef: 'error', no-unused-vars: ['error', {vars: "local"}], no-redeclare: 'error' */
-/* global $NonMaybeType, $Partial, $ReadOnly, $ReadOnlyArray */
+/* global $NonMaybeType, Partial, $ReadOnly, $ReadOnlyArray */
 
 'use strict';
 
@@ -56,6 +63,10 @@ export function isBigIntLiteralTypeAnnotation(
   return node.type === 'BigIntLiteralTypeAnnotation';
 }
 
+export function isBigIntTypeAnnotation(node: ESNode | Token): boolean %checks {
+  return node.type === 'BigIntTypeAnnotation';
+}
+
 export function isBinaryExpression(node: ESNode | Token): boolean %checks {
   return node.type === 'BinaryExpression';
 }
@@ -1024,78 +1035,78 @@ export function isYieldToken(node: ESNode | Token): boolean %checks {
 
 export function isAsKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'as'
+    (node.type === 'Identifier' && node.name === 'as') ||
+    (node.type === 'Keyword' && node.value === 'as')
   );
 }
 
 export function isAsyncKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'async'
+    (node.type === 'Identifier' && node.name === 'async') ||
+    (node.type === 'Keyword' && node.value === 'async')
   );
 }
 
 export function isAwaitKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'await'
+    (node.type === 'Identifier' && node.name === 'await') ||
+    (node.type === 'Keyword' && node.value === 'await')
   );
 }
 
 export function isDeclareKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'declare'
+    (node.type === 'Identifier' && node.name === 'declare') ||
+    (node.type === 'Keyword' && node.value === 'declare')
   );
 }
 
 export function isFromKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'from'
+    (node.type === 'Identifier' && node.name === 'from') ||
+    (node.type === 'Keyword' && node.value === 'from')
   );
 }
 
 export function isGetKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'get'
+    (node.type === 'Identifier' && node.name === 'get') ||
+    (node.type === 'Keyword' && node.value === 'get')
   );
 }
 
 export function isLetKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'let'
+    (node.type === 'Identifier' && node.name === 'let') ||
+    (node.type === 'Keyword' && node.value === 'let')
   );
 }
 
 export function isModuleKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'module'
+    (node.type === 'Identifier' && node.name === 'module') ||
+    (node.type === 'Keyword' && node.value === 'module')
   );
 }
 
 export function isOfKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'of'
+    (node.type === 'Identifier' && node.name === 'of') ||
+    (node.type === 'Keyword' && node.value === 'of')
   );
 }
 
 export function isSetKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'set'
+    (node.type === 'Identifier' && node.name === 'set') ||
+    (node.type === 'Keyword' && node.value === 'set')
   );
 }
 
 export function isTypeKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'type'
+    (node.type === 'Identifier' && node.name === 'type') ||
+    (node.type === 'Keyword' && node.value === 'type')
   );
 }
 

package/dist/getModuleDocblock.js

@@ -0,0 +1,112 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getModuleDocblock = getModuleDocblock;
+exports.parseDocblockString = parseDocblockString;
+const DIRECTIVE_REGEX = /^\s*@([a-zA-Z0-9_-]+)( +.+)?$/;
+
+function parseDocblockString(docblock) {
+  const directiveLines = docblock.split('\n') // remove the leading " *" from each line
+  .map(line => line.trimStart().replace(/^\* ?/, '').trim()).filter(line => line.startsWith('@'));
+  const directives = // $FlowExpectedError[incompatible-type] - flow types  this return as {...}
+  Object.create(null);
+
+  for (const line of directiveLines) {
+    var _match$;
+
+    const match = DIRECTIVE_REGEX.exec(line);
+
+    if (match == null) {
+      continue;
+    }
+
+    const name = match[1]; // explicitly use an empty string if there's no value
+    // this way the array length tracks how many instances of the directive there was
+
+    const value = ((_match$ = match[2]) != null ? _match$ : '').trim();
+
+    if (directives[name]) {
+      directives[name].push(value);
+    } else {
+      directives[name] = [value];
+    }
+  }
+
+  return directives;
+}
+
+function getModuleDocblock(hermesProgram) {
+  const docblockNode = (() => {
+    if (hermesProgram.type !== 'Program') {
+      return null;
+    } // $FlowExpectedError[incompatible-type] - escape out of the unsafe hermes types
+
+
+    const program = hermesProgram;
+
+    if (program.comments.length === 0) {
+      return null;
+    }
+
+    const firstComment = (() => {
+      const first = program.comments[0];
+
+      if (first.type === 'Block') {
+        return first;
+      }
+
+      if (program.comments.length === 1) {
+        return null;
+      } // ESLint will always strip out the shebang comment from the code before passing it to the parser
+      // https://github.com/eslint/eslint/blob/21d647904dc30f9484b22acdd9243a6d0ecfba38/lib/linter/linter.js#L779
+      // this means that we're forced to parse it as a line comment :(
+      // this hacks around it by selecting the second comment in this case
+
+
+      const second = program.comments[1];
+
+      if (first.type === 'Line' && first.range[0] === 0 && second.type === 'Block') {
+        return second;
+      }
+
+      return null;
+    })();
+
+    if (firstComment == null) {
+      return null;
+    }
+    /*
+    Handle cases like this where the comment isn't actually the first thing in the code:
+    ```
+    const x = 1; /* docblock *./
+    ```
+    */
+
+
+    if (program.body.length > 0 && program.body[0].range[0] < firstComment.range[0]) {
+      return null;
+    }
+
+    return firstComment;
+  })();
+
+  if (docblockNode == null) {
+    return null;
+  }
+
+  return {
+    directives: parseDocblockString(docblockNode.value),
+    comment: docblockNode
+  };
+}

package/dist/getModuleDocblock.js.flow

@@ -0,0 +1,118 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {HermesNode} from './HermesAST';
+import type {DocblockDirectives, Program} from 'hermes-estree';
+
+const DIRECTIVE_REGEX = /^\s*@([a-zA-Z0-9_-]+)( +.+)?$/;
+
+export function parseDocblockString(docblock: string): DocblockDirectives {
+  const directiveLines = docblock
+    .split('\n')
+    // remove the leading " *" from each line
+    .map(line => line.trimStart().replace(/^\* ?/, '').trim())
+    .filter(line => line.startsWith('@'));
+
+  const directives: {
+    [string]: Array<string>,
+  } =
+    // $FlowExpectedError[incompatible-type] - flow types  this return as {...}
+    Object.create(null);
+
+  for (const line of directiveLines) {
+    const match = DIRECTIVE_REGEX.exec(line);
+    if (match == null) {
+      continue;
+    }
+    const name = match[1];
+    // explicitly use an empty string if there's no value
+    // this way the array length tracks how many instances of the directive there was
+    const value = (match[2] ?? '').trim();
+    if (directives[name]) {
+      directives[name].push(value);
+    } else {
+      directives[name] = [value];
+    }
+  }
+
+  return directives;
+}
+
+export function getModuleDocblock(
+  hermesProgram: HermesNode,
+): Program['docblock'] {
+  const docblockNode = (() => {
+    if (hermesProgram.type !== 'Program') {
+      return null;
+    }
+
+    // $FlowExpectedError[incompatible-type] - escape out of the unsafe hermes types
+    const program: Program = hermesProgram;
+
+    if (program.comments.length === 0) {
+      return null;
+    }
+
+    const firstComment = (() => {
+      const first = program.comments[0];
+      if (first.type === 'Block') {
+        return first;
+      }
+
+      if (program.comments.length === 1) {
+        return null;
+      }
+
+      // ESLint will always strip out the shebang comment from the code before passing it to the parser
+      // https://github.com/eslint/eslint/blob/21d647904dc30f9484b22acdd9243a6d0ecfba38/lib/linter/linter.js#L779
+      // this means that we're forced to parse it as a line comment :(
+      // this hacks around it by selecting the second comment in this case
+      const second = program.comments[1];
+      if (
+        first.type === 'Line' &&
+        first.range[0] === 0 &&
+        second.type === 'Block'
+      ) {
+        return second;
+      }
+
+      return null;
+    })();
+    if (firstComment == null) {
+      return null;
+    }
+
+    /*
+    Handle cases like this where the comment isn't actually the first thing in the code:
+    ```
+    const x = 1; /* docblock *./
+    ```
+    */
+    if (
+      program.body.length > 0 &&
+      program.body[0].range[0] < firstComment.range[0]
+    ) {
+      return null;
+    }
+
+    return firstComment;
+  })();
+
+  if (docblockNode == null) {
+    return null;
+  }
+
+  return {
+    directives: parseDocblockString(docblockNode.value),
+    comment: docblockNode,
+  };
+}

package/dist/predicates.js

@@ -29,7 +29,9 @@ var _exportNames = {
   isNullLiteral: true,
   isNumericLiteral: true,
   isRegExpLiteral: true,
-  isStringLiteral: true
+  isStringLiteral: true,
+  isExpression: true,
+  isStatement: true
 };
 exports.isBigIntLiteral = isBigIntLiteral;
 exports.isBooleanLiteral = isBooleanLiteral;
@@ -37,6 +39,7 @@ exports.isClass = isClass;
 exports.isClassMember = isClassMember;
 exports.isClassMemberWithNonComputedName = isClassMemberWithNonComputedName;
 exports.isComment = isComment;
+exports.isExpression = isExpression;
 exports.isFunction = isFunction;
 exports.isMemberExpressionWithNonComputedProperty = isMemberExpressionWithNonComputedProperty;
 exports.isMethodDefinitionWithNonComputedName = isMethodDefinitionWithNonComputedName;
@@ -47,6 +50,7 @@ exports.isObjectPropertyWithShorthand = isObjectPropertyWithShorthand;
 exports.isOptionalMemberExpressionWithNonComputedProperty = isOptionalMemberExpressionWithNonComputedProperty;
 exports.isPropertyDefinitionWithNonComputedName = isPropertyDefinitionWithNonComputedName;
 exports.isRegExpLiteral = isRegExpLiteral;
+exports.isStatement = isStatement;
 exports.isStringLiteral = isStringLiteral;
 
 var _predicates = require("./generated/predicates");
@@ -124,4 +128,12 @@ function isRegExpLiteral(node) {
 
 function isStringLiteral(node) {
   return (0, _predicates.isLiteral)(node) && node.literalType === 'string';
+}
+
+function isExpression(node) {
+  return (0, _predicates.isThisExpression)(node) || (0, _predicates.isArrayExpression)(node) || (0, _predicates.isObjectExpression)(node) || (0, _predicates.isFunctionExpression)(node) || (0, _predicates.isArrowFunctionExpression)(node) || (0, _predicates.isYieldExpression)(node) || (0, _predicates.isLiteral)(node) || (0, _predicates.isUnaryExpression)(node) || (0, _predicates.isUpdateExpression)(node) || (0, _predicates.isBinaryExpression)(node) || (0, _predicates.isAssignmentExpression)(node) || (0, _predicates.isLogicalExpression)(node) || (0, _predicates.isMemberExpression)(node) || (0, _predicates.isConditionalExpression)(node) || (0, _predicates.isCallExpression)(node) || (0, _predicates.isNewExpression)(node) || (0, _predicates.isSequenceExpression)(node) || (0, _predicates.isTemplateLiteral)(node) || (0, _predicates.isTaggedTemplateExpression)(node) || (0, _predicates.isClassExpression)(node) || (0, _predicates.isMetaProperty)(node) || (0, _predicates.isIdentifier)(node) || (0, _predicates.isAwaitExpression)(node) || (0, _predicates.isImportExpression)(node) || (0, _predicates.isChainExpression)(node) || (0, _predicates.isTypeCastExpression)(node) || (0, _predicates.isJSXFragment)(node) || (0, _predicates.isJSXElement)(node);
+}
+
+function isStatement(node) {
+  return (0, _predicates.isBlockStatement)(node) || (0, _predicates.isBreakStatement)(node) || (0, _predicates.isClassDeclaration)(node) || (0, _predicates.isContinueStatement)(node) || (0, _predicates.isDebuggerStatement)(node) || (0, _predicates.isDeclareClass)(node) || (0, _predicates.isDeclareVariable)(node) || (0, _predicates.isDeclareFunction)(node) || (0, _predicates.isDeclareInterface)(node) || (0, _predicates.isDeclareModule)(node) || (0, _predicates.isDeclareOpaqueType)(node) || (0, _predicates.isDeclareTypeAlias)(node) || (0, _predicates.isDoWhileStatement)(node) || (0, _predicates.isEmptyStatement)(node) || (0, _predicates.isEnumDeclaration)(node) || (0, _predicates.isExpressionStatement)(node) || (0, _predicates.isForInStatement)(node) || (0, _predicates.isForOfStatement)(node) || (0, _predicates.isForStatement)(node) || (0, _predicates.isFunctionDeclaration)(node) || (0, _predicates.isIfStatement)(node) || (0, _predicates.isInterfaceDeclaration)(node) || (0, _predicates.isLabeledStatement)(node) || (0, _predicates.isOpaqueType)(node) || (0, _predicates.isReturnStatement)(node) || (0, _predicates.isSwitchStatement)(node) || (0, _predicates.isThrowStatement)(node) || (0, _predicates.isTryStatement)(node) || (0, _predicates.isTypeAlias)(node) || (0, _predicates.isVariableDeclaration)(node) || (0, _predicates.isWhileStatement)(node) || (0, _predicates.isWithStatement)(node);
 }

package/dist/predicates.js.flow

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow strict
+ * @flow strict-local
  * @format
  */
 
@@ -13,18 +13,71 @@
 import type {ESNode, Token} from './types';
 
 import {
+  isArrayExpression,
   isArrowFunctionExpression,
+  isAssignmentExpression,
+  isAwaitExpression,
+  isBinaryExpression,
   isBlockComment,
+  isBlockStatement,
+  isBreakStatement,
+  isCallExpression,
+  isChainExpression,
   isClassDeclaration,
   isClassExpression,
+  isConditionalExpression,
+  isContinueStatement,
+  isDebuggerStatement,
+  isDeclareClass,
+  isDeclareFunction,
+  isDeclareInterface,
+  isDeclareModule,
+  isDeclareOpaqueType,
+  isDeclareTypeAlias,
+  isDeclareVariable,
+  isDoWhileStatement,
+  isEmptyStatement,
+  isEnumDeclaration,
+  isExpressionStatement,
+  isForInStatement,
+  isForOfStatement,
+  isForStatement,
   isFunctionDeclaration,
   isFunctionExpression,
+  isIdentifier,
+  isIfStatement,
+  isImportExpression,
+  isInterfaceDeclaration,
+  isJSXElement,
+  isJSXFragment,
+  isLabeledStatement,
   isLineComment,
   isLiteral,
+  isLogicalExpression,
   isMemberExpression,
+  isMetaProperty,
   isMethodDefinition,
-  isPropertyDefinition,
+  isNewExpression,
+  isObjectExpression,
+  isOpaqueType,
   isProperty,
+  isPropertyDefinition,
+  isReturnStatement,
+  isSequenceExpression,
+  isSwitchStatement,
+  isTaggedTemplateExpression,
+  isTemplateLiteral,
+  isThisExpression,
+  isThrowStatement,
+  isTryStatement,
+  isTypeAlias,
+  isTypeCastExpression,
+  isUnaryExpression,
+  isUpdateExpression,
+  isVariableDeclaration,
+  isWhileStatement,
+  isWithStatement,
+  isYieldExpression,
 } from './generated/predicates';
 
 export * from './generated/predicates';
@@ -112,3 +165,73 @@ export function isRegExpLiteral(node: ESNode): boolean %checks {
 export function isStringLiteral(node: ESNode): boolean %checks {
   return isLiteral(node) && node.literalType === 'string';
 }
+
+export function isExpression(node: ESNode): boolean %checks {
+  return (
+    isThisExpression(node) ||
+    isArrayExpression(node) ||
+    isObjectExpression(node) ||
+    isFunctionExpression(node) ||
+    isArrowFunctionExpression(node) ||
+    isYieldExpression(node) ||
+    isLiteral(node) ||
+    isUnaryExpression(node) ||
+    isUpdateExpression(node) ||
+    isBinaryExpression(node) ||
+    isAssignmentExpression(node) ||
+    isLogicalExpression(node) ||
+    isMemberExpression(node) ||
+    isConditionalExpression(node) ||
+    isCallExpression(node) ||
+    isNewExpression(node) ||
+    isSequenceExpression(node) ||
+    isTemplateLiteral(node) ||
+    isTaggedTemplateExpression(node) ||
+    isClassExpression(node) ||
+    isMetaProperty(node) ||
+    isIdentifier(node) ||
+    isAwaitExpression(node) ||
+    isImportExpression(node) ||
+    isChainExpression(node) ||
+    isTypeCastExpression(node) ||
+    isJSXFragment(node) ||
+    isJSXElement(node)
+  );
+}
+
+export function isStatement(node: ESNode): boolean %checks {
+  return (
+    isBlockStatement(node) ||
+    isBreakStatement(node) ||
+    isClassDeclaration(node) ||
+    isContinueStatement(node) ||
+    isDebuggerStatement(node) ||
+    isDeclareClass(node) ||
+    isDeclareVariable(node) ||
+    isDeclareFunction(node) ||
+    isDeclareInterface(node) ||
+    isDeclareModule(node) ||
+    isDeclareOpaqueType(node) ||
+    isDeclareTypeAlias(node) ||
+    isDoWhileStatement(node) ||
+    isEmptyStatement(node) ||
+    isEnumDeclaration(node) ||
+    isExpressionStatement(node) ||
+    isForInStatement(node) ||
+    isForOfStatement(node) ||
+    isForStatement(node) ||
+    isFunctionDeclaration(node) ||
+    isIfStatement(node) ||
+    isInterfaceDeclaration(node) ||
+    isLabeledStatement(node) ||
+    isOpaqueType(node) ||
+    isReturnStatement(node) ||
+    isSwitchStatement(node) ||
+    isThrowStatement(node) ||
+    isTryStatement(node) ||
+    isTypeAlias(node) ||
+    isVariableDeclaration(node) ||
+    isWhileStatement(node) ||
+    isWithStatement(node)
+  );
+}