@ohos-ports/hermes-parser 0.37.0-beta.0

package/dist/utils/Builders.js

@@ -0,0 +1,190 @@
+/**
+ * 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.
+ *
+ *  strict
+ * @format
+ */
+'use strict'; // Rely on the mapper to fix up parent relationships.
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EMPTY_PARENT = void 0;
+exports.callExpression = callExpression;
+exports.conjunction = conjunction;
+exports.createDefaultPosition = createDefaultPosition;
+exports.disjunction = disjunction;
+exports.etc = etc;
+exports.ident = ident;
+exports.iife = iife;
+exports.nullLiteral = nullLiteral;
+exports.numberLiteral = numberLiteral;
+exports.stringLiteral = stringLiteral;
+exports.throwStatement = throwStatement;
+exports.typeofExpression = typeofExpression;
+exports.variableDeclaration = variableDeclaration;
+const EMPTY_PARENT = null;
+exports.EMPTY_PARENT = EMPTY_PARENT;
+
+function createDefaultPosition() {
+  return {
+    line: 1,
+    column: 0
+  };
+}
+
+function etc({
+  loc,
+  range,
+  parent
+} = {}) {
+  return {
+    loc: {
+      start: (loc == null ? void 0 : loc.start) != null ? loc.start : createDefaultPosition(),
+      end: (loc == null ? void 0 : loc.end) != null ? loc.end : createDefaultPosition()
+    },
+    range: range != null ? range : [0, 0],
+    parent: parent != null ? parent : EMPTY_PARENT
+  };
+}
+
+function ident(name, info) {
+  return {
+    type: 'Identifier',
+    name,
+    optional: false,
+    typeAnnotation: null,
+    ...etc(info)
+  };
+}
+
+function stringLiteral(value, info) {
+  return {
+    type: 'Literal',
+    value,
+    raw: `"${value}"`,
+    literalType: 'string',
+    ...etc(info)
+  };
+}
+
+function numberLiteral(value, info) {
+  return {
+    type: 'Literal',
+    value,
+    raw: String(value),
+    literalType: 'numeric',
+    ...etc(info)
+  };
+}
+
+function nullLiteral(info) {
+  return {
+    type: 'Literal',
+    value: null,
+    raw: 'null',
+    literalType: 'null',
+    ...etc(info)
+  };
+}
+
+function conjunction(tests) {
+  if (tests.length === 0) {
+    throw new Error('Must have at least one test.');
+  }
+
+  return tests.reduce((acc, test) => ({
+    type: 'LogicalExpression',
+    left: acc,
+    right: test,
+    operator: '&&',
+    ...etc()
+  }));
+}
+
+function disjunction(tests) {
+  if (tests.length === 0) {
+    throw new Error('Must have at least one test.');
+  }
+
+  return tests.reduce((acc, test) => ({
+    type: 'LogicalExpression',
+    left: acc,
+    right: test,
+    operator: '||',
+    ...etc()
+  }));
+}
+
+function variableDeclaration(kind, id, init, info) {
+  return {
+    type: 'VariableDeclaration',
+    kind,
+    declarations: [{
+      type: 'VariableDeclarator',
+      init,
+      id,
+      ...etc(),
+      parent: EMPTY_PARENT
+    }],
+    ...etc(info)
+  };
+}
+
+function callExpression(callee, args, info) {
+  return {
+    type: 'CallExpression',
+    callee,
+    arguments: args,
+    typeArguments: null,
+    optional: false,
+    ...etc(info)
+  };
+}
+
+function throwStatement(arg, info) {
+  return {
+    type: 'ThrowStatement',
+    argument: callExpression(ident('Error'), [arg]),
+    ...etc(info)
+  };
+}
+
+function iife(statements, params = [], args = []) {
+  const callee = {
+    type: 'ArrowFunctionExpression',
+    params,
+    expression: false,
+    async: false,
+    predicate: null,
+    returnType: null,
+    typeParameters: null,
+    id: null,
+    body: {
+      type: 'BlockStatement',
+      body: statements,
+      ...etc()
+    },
+    ...etc()
+  };
+  return callExpression(callee, args);
+}
+
+function typeofExpression(arg, kind) {
+  return {
+    type: 'BinaryExpression',
+    left: {
+      type: 'UnaryExpression',
+      operator: 'typeof',
+      argument: arg,
+      prefix: true,
+      ...etc()
+    },
+    right: stringLiteral(kind),
+    operator: '===',
+    ...etc()
+  };
+}

package/dist/utils/Builders.js.flow

@@ -0,0 +1,218 @@
+/**
+ * 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 {
+  ArrowFunctionExpression,
+  BinaryExpression,
+  BindingName,
+  CallExpression,
+  ESNode,
+  Expression,
+  Identifier,
+  LogicalExpression,
+  NullLiteral,
+  NumericLiteral,
+  Position,
+  Range,
+  SourceLocation,
+  SpreadElement,
+  Statement,
+  StringLiteral,
+  Super,
+  ThrowStatement,
+  VariableDeclaration,
+} from 'hermes-estree';
+
+// Rely on the mapper to fix up parent relationships.
+export const EMPTY_PARENT: $FlowFixMe = null;
+
+export function createDefaultPosition(): Position {
+  return {
+    line: 1,
+    column: 0,
+  };
+}
+
+export type Etc = {
+  parent?: ESNode,
+  loc?: SourceLocation,
+  range?: Range,
+};
+
+export function etc({loc, range, parent}: Etc = {}): {
+  parent: ESNode,
+  loc: SourceLocation,
+  range: Range,
+} {
+  return {
+    loc: {
+      start: loc?.start != null ? loc.start : createDefaultPosition(),
+      end: loc?.end != null ? loc.end : createDefaultPosition(),
+    },
+    range: range ?? [0, 0],
+    parent: parent ?? EMPTY_PARENT,
+  };
+}
+
+export function ident(name: string, info?: Etc): Identifier {
+  return {
+    type: 'Identifier',
+    name,
+    optional: false,
+    typeAnnotation: null,
+    ...etc(info),
+  };
+}
+
+export function stringLiteral(value: string, info?: Etc): StringLiteral {
+  return {
+    type: 'Literal',
+    value,
+    raw: `"${value}"`,
+    literalType: 'string',
+    ...etc(info),
+  };
+}
+
+export function numberLiteral(value: number, info?: Etc): NumericLiteral {
+  return {
+    type: 'Literal',
+    value,
+    raw: String(value),
+    literalType: 'numeric',
+    ...etc(info),
+  };
+}
+
+export function nullLiteral(info?: Etc): NullLiteral {
+  return {
+    type: 'Literal',
+    value: null,
+    raw: 'null',
+    literalType: 'null',
+    ...etc(info),
+  };
+}
+
+export function conjunction(tests: ReadonlyArray<Expression>): Expression {
+  if (tests.length === 0) {
+    throw new Error('Must have at least one test.');
+  }
+  return tests.reduce((acc, test): LogicalExpression => ({
+    type: 'LogicalExpression',
+    left: acc,
+    right: test,
+    operator: '&&',
+    ...etc(),
+  }));
+}
+
+export function disjunction(tests: ReadonlyArray<Expression>): Expression {
+  if (tests.length === 0) {
+    throw new Error('Must have at least one test.');
+  }
+  return tests.reduce((acc, test): LogicalExpression => ({
+    type: 'LogicalExpression',
+    left: acc,
+    right: test,
+    operator: '||',
+    ...etc(),
+  }));
+}
+
+export function variableDeclaration(
+  kind: VariableDeclaration['kind'],
+  id: BindingName,
+  init: Expression,
+  info?: Etc,
+): VariableDeclaration {
+  return {
+    type: 'VariableDeclaration',
+    kind,
+    declarations: [
+      {
+        type: 'VariableDeclarator',
+        init,
+        id,
+        ...etc(),
+        parent: EMPTY_PARENT,
+      },
+    ],
+    ...etc(info),
+  };
+}
+
+export function callExpression(
+  callee: Expression | Super,
+  args: ReadonlyArray<Expression | SpreadElement>,
+  info?: Etc,
+): CallExpression {
+  return {
+    type: 'CallExpression',
+    callee,
+    arguments: args,
+    typeArguments: null,
+    optional: false,
+    ...etc(info),
+  };
+}
+
+export function throwStatement(arg: Expression, info?: Etc): ThrowStatement {
+  return {
+    type: 'ThrowStatement',
+    argument: callExpression(ident('Error'), [arg]),
+    ...etc(info),
+  };
+}
+
+export function iife(
+  statements: ReadonlyArray<Statement>,
+  params: ReadonlyArray<BindingName> = [],
+  args: ReadonlyArray<Expression> = [],
+): CallExpression {
+  const callee: ArrowFunctionExpression = {
+    type: 'ArrowFunctionExpression',
+    params,
+    expression: false,
+    async: false,
+    predicate: null,
+    returnType: null,
+    typeParameters: null,
+    id: null,
+    body: {
+      type: 'BlockStatement',
+      body: statements,
+      ...etc(),
+    },
+    ...etc(),
+  };
+  return callExpression(callee, args);
+}
+
+export function typeofExpression(
+  arg: Expression,
+  kind: string,
+): BinaryExpression {
+  return {
+    type: 'BinaryExpression',
+    left: {
+      type: 'UnaryExpression',
+      operator: 'typeof',
+      argument: arg,
+      prefix: true,
+      ...etc(),
+    },
+    right: stringLiteral(kind),
+    operator: '===',
+    ...etc(),
+  };
+}

package/dist/utils/GenID.js

@@ -0,0 +1,46 @@
+/**
+ * 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.
+ *
+ *  strict
+ * @format
+ */
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const genPrefix = '$$gen$';
+
+class GenID {
+  constructor(uniqueTransformPrefix) {
+    this.genN = 0;
+    this.used = new Set();
+    this.prefix = void 0;
+    this.prefix = `${genPrefix}${uniqueTransformPrefix}`;
+  }
+
+  id() {
+    let name;
+
+    do {
+      name = `${this.prefix}${this.genN}`;
+      this.genN++;
+    } while (this.used.has(name));
+
+    this.used.add(name);
+    return name;
+  }
+
+  addUsage(name) {
+    if (name.startsWith(this.prefix)) {
+      this.used.add(name);
+    }
+  }
+
+}
+
+exports.default = GenID;

package/dist/utils/GenID.js.flow

@@ -0,0 +1,39 @@
+/**
+ * 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';
+
+const genPrefix = '$$gen$';
+
+export default class GenID {
+  genN: number = 0;
+  readonly used: Set<string> = new Set();
+  readonly prefix: string;
+
+  constructor(uniqueTransformPrefix: string) {
+    this.prefix = `${genPrefix}${uniqueTransformPrefix}`;
+  }
+
+  id(): string {
+    let name;
+    do {
+      name = `${this.prefix}${this.genN}`;
+      this.genN++;
+    } while (this.used.has(name));
+    this.used.add(name);
+    return name;
+  }
+
+  addUsage(name: string): void {
+    if (name.startsWith(this.prefix)) {
+      this.used.add(name);
+    }
+  }
+}

package/dist/utils/createSyntaxError.js

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ *
+ *  strict
+ * @format
+ */
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSyntaxError = createSyntaxError;
+
+function createSyntaxError(node, err) {
+  const syntaxError = new SyntaxError(err); // $FlowExpectedError[prop-missing]
+
+  syntaxError.loc = {
+    line: node.loc.start.line,
+    column: node.loc.start.column
+  };
+  return syntaxError;
+}

package/dist/utils/createSyntaxError.js.flow

@@ -0,0 +1,24 @@
+/**
+ * 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 {ESNode} from 'hermes-estree';
+
+export function createSyntaxError(node: ESNode, err: string): SyntaxError {
+  const syntaxError = new SyntaxError(err);
+  // $FlowExpectedError[prop-missing]
+  syntaxError.loc = {
+    line: node.loc.start.line,
+    column: node.loc.start.column,
+  };
+
+  return syntaxError;
+}

package/dist/utils/isReservedWord.js

@@ -0,0 +1,62 @@
+/**
+ * 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.
+ *
+ *  strict
+ * @format
+ */
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isReservedWord;
+
+function isReservedWord(name) {
+  switch (name) {
+    case 'await':
+    case 'break':
+    case 'case':
+    case 'catch':
+    case 'class':
+    case 'const':
+    case 'continue':
+    case 'debugger':
+    case 'default':
+    case 'delete':
+    case 'do':
+    case 'else':
+    case 'enum':
+    case 'export':
+    case 'extends':
+    case 'false':
+    case 'finally':
+    case 'for':
+    case 'function':
+    case 'if':
+    case 'import':
+    case 'in':
+    case 'instanceof':
+    case 'new':
+    case 'null':
+    case 'return':
+    case 'super':
+    case 'switch':
+    case 'this':
+    case 'throw':
+    case 'true':
+    case 'try':
+    case 'typeof':
+    case 'var':
+    case 'void':
+    case 'while':
+    case 'with':
+    case 'yield':
+      return true;
+
+    default:
+      return false;
+  }
+}

package/dist/utils/isReservedWord.js.flow

@@ -0,0 +1,57 @@
+/**
+ * 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';
+
+export default function isReservedWord(name: string): boolean {
+  switch (name) {
+    case 'await':
+    case 'break':
+    case 'case':
+    case 'catch':
+    case 'class':
+    case 'const':
+    case 'continue':
+    case 'debugger':
+    case 'default':
+    case 'delete':
+    case 'do':
+    case 'else':
+    case 'enum':
+    case 'export':
+    case 'extends':
+    case 'false':
+    case 'finally':
+    case 'for':
+    case 'function':
+    case 'if':
+    case 'import':
+    case 'in':
+    case 'instanceof':
+    case 'new':
+    case 'null':
+    case 'return':
+    case 'super':
+    case 'switch':
+    case 'this':
+    case 'throw':
+    case 'true':
+    case 'try':
+    case 'typeof':
+    case 'var':
+    case 'void':
+    case 'while':
+    case 'with':
+    case 'yield':
+      return true;
+    default:
+      return false;
+  }
+}