13744972796

Committed 09 Mar 2025 04:48AM UTC coverage: 65.487% (-0.02%) from 65.505%

Build # 13744972796

Build Type

push

github

Committed by

Siubaak

Commit Message

[fix] use Reflect.contruct for calling super

Run Details

1477 of 2311 branches covered (63.91%)

Branch coverage included in aggregate %.

8 of 21 new or added lines in 3 files covered. (38.1%)

14 existing lines in 2 files now uncovered.

1354 of 2012 relevant lines covered (67.3%)

1273.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

54.91

/src/evaluate/expression.ts

import { define, freeze, getGetter, getSetter, createSymbol, assign, getDptor, callSuper, WINDOW } from '../share/util'
import { SUPER, NOCTOR, AWAIT, CLSCTOR, NEWTARGET, SUPERCALL, PRIVATE, IMPORT } from '../share/const'
import { pattern, createFunc, createClass } from './helper'
import { Variable, Prop } from '../scope/variable'
import { Identifier } from './identifier'
import { Literal } from './literal'
import * as acorn from 'acorn'
import Scope from '../scope'
import evaluate from '.'

export function* ThisExpression(node: acorn.ThisExpression, scope: Scope) {
  const superCall = scope.find(SUPERCALL)
  if (superCall && superCall.get() !== true) {
    throw new ReferenceError('Must call super constructor in derived class '
      + 'before accessing \'this\' or returning from derived constructor')
  } else {
    return scope.find('this').get()
  }
}

export function* ArrayExpression(node: acorn.ArrayExpression, scope: Scope) {
  let results: any[] = []
  for (let i = 0; i < node.elements.length; i++) {
    const item = node.elements[i]
    if (item.type === 'SpreadElement') {
      results = results.concat(yield* SpreadElement(item, scope))
    } else {
      results.push(yield* evaluate(item, scope))
    }
  }
  return results
}

export function* ObjectExpression(node: acorn.ObjectExpression, scope: Scope) {
  const object: { [key: string]: any } = {}
  for (let i = 0; i < node.properties.length; i++) {
    const property = node.properties[i]
    if (property.type === 'SpreadElement') {
      assign(object, yield* SpreadElement(property, scope, { spreadProps: true }))
    } else {
      let key: string
      const propKey = property.key
      if (property.computed) {
        key = yield* evaluate(propKey, scope)
      } else {
        if (propKey.type === 'Identifier') {
          key = propKey.name
        } else {
          key = '' + (yield* Literal(propKey as acorn.Literal, scope))
        }
      }
  
      const value = yield* evaluate(property.value, scope)
  
      const propKind = property.kind
      if (propKind === 'init') {
        object[key] = value
      } else if (propKind === 'get') {
        const oriDptor = getDptor(object, key)
        define(object, key, {
          get: value,
          set: oriDptor && oriDptor.set,
          enumerable: true,
          configurable: true
        })
      } else { // propKind === 'set'
        const oriDptor = getDptor(object, key)
        define(object, key, {
          get: oriDptor && oriDptor.get,
          set: value,
          enumerable: true,
          configurable: true
        })
      }
    }
  }
  return object
}

export function* FunctionExpression(node: acorn.FunctionExpression, scope: Scope) {
  if (node.id && node.id.name) {
    // it's for accessing function expression by its name inside
    // e.g. const a = function b() { console.log(b) }
    const tmpScope = new Scope(scope)
    const func = createFunc(node, tmpScope)
    tmpScope.const(node.id.name, func)
    return func
  } else {
    return createFunc(node, scope)
  }
}

export function* UnaryExpression(node: acorn.UnaryExpression, scope: Scope) {
  const arg = node.argument
  switch (node.operator) {
    case '+': return +(yield* evaluate(arg, scope))
    case '-': return -(yield* evaluate(arg, scope))
    case '!': return !(yield* evaluate(arg, scope))
    case '~': return ~(yield* evaluate(arg, scope))
    case 'void': return void (yield* evaluate(arg, scope))
    case 'typeof':
      if (arg.type === 'Identifier') {
        return typeof (yield* Identifier(arg, scope, { throwErr: false }))
      } else {
        return typeof (yield* evaluate(arg, scope))
      }
    case 'delete':
      if (arg.type === 'MemberExpression') {
        const variable: Prop = yield* MemberExpression(arg, scope, { getVar: true })
        return variable.del()
      } else if (arg.type === 'Identifier') {
        throw new SyntaxError('Delete of an unqualified identifier in strict mode')
      } else {
        yield* evaluate(arg, scope)
        return true
      }
    /* istanbul ignore next */
    default: throw new SyntaxError(`Unexpected token ${node.operator}`)
  }
}

export function* UpdateExpression(node: acorn.UpdateExpression, scope: Scope) {
  const arg = node.argument
  
  let variable: Variable
  if (arg.type === 'Identifier') {
    variable = yield* Identifier(arg, scope, { getVar: true })
  } else if (arg.type === 'MemberExpression') {
    variable = yield* MemberExpression(arg, scope, { getVar: true })
  } else {
    /* istanbul ignore next */
    throw new SyntaxError('Unexpected token')
  }

  const value = variable.get()
  if (node.operator === '++') {
    variable.set(value + 1)
    return node.prefix ? variable.get() : value
  } else if (node.operator === '--') {
    variable.set(value - 1)
    return node.prefix ? variable.get() : value
  } else {
    /* istanbul ignore next */
    throw new SyntaxError(`Unexpected token ${node.operator}`)
  }
}

export function* BinaryExpression(node: acorn.BinaryExpression, scope: Scope) {
  let left: any
  let right: any

  if (node.left.type === 'PrivateIdentifier') {
    left = node.left.name
    right = yield* evaluate(node.right, scope)
    right = right[PRIVATE] || {} // compatible with checking by "#private in object"
  } else {
    left = yield* evaluate(node.left, scope)
    right = yield* evaluate(node.right, scope)
  }

  switch (node.operator) {
    case '==': return left == right
    case '!=': return left != right
    case '===': return left === right
    case '!==': return left !== right
    case '<': return left < right
    case '<=': return left <= right
    case '>': return left > right
    case '>=': return left >= right
    case '<<': return left << right
    case '>>': return left >> right
    case '>>>': return left >>> right
    case '+': return left + right
    case '-': return left - right
    case '*': return left * right
    case '**': return left ** right
    case '/': return left / right
    case '%': return left % right
    case '|': return left | right
    case '^': return left ^ right
    case '&': return left & right
    case 'in': return left in right
    case 'instanceof': return left instanceof right
    /* istanbul ignore next */
    default: throw new SyntaxError(`Unexpected token ${node.operator}`)
  }
}

export function* AssignmentExpression(node: acorn.AssignmentExpression, scope: Scope) {
  const left = node.left
  let variable: Variable
  if (left.type === 'Identifier') {
    variable = yield* Identifier(left, scope, { getVar: true, throwErr: false })
    if (!variable) {
      const win = scope.global().find('window').get()
      variable = new Prop(win, left.name)
    }
  } else if (left.type === 'MemberExpression') {
    variable = yield* MemberExpression(left, scope, { getVar: true })
  } else {
    const value = yield* evaluate(node.right, scope)
    return yield* pattern(left, scope, { feed: value })
  }

  const value = yield* evaluate(node.right, scope)
  switch (node.operator) {
    case '=': variable.set(value); return variable.get()
    case '+=': variable.set(variable.get() + value); return variable.get()
    case '-=': variable.set(variable.get() - value); return variable.get()
    case '*=': variable.set(variable.get() * value); return variable.get()
    case '/=': variable.set(variable.get() / value); return variable.get()
    case '%=': variable.set(variable.get() % value); return variable.get()
    case '**=': variable.set(variable.get() ** value); return variable.get()
    case '<<=': variable.set(variable.get() << value); return variable.get()
    case '>>=': variable.set(variable.get() >> value); return variable.get()
    case '>>>=': variable.set(variable.get() >>> value); return variable.get()
    case '|=': variable.set(variable.get() | value); return variable.get()
    case '^=': variable.set(variable.get() ^ value); return variable.get()
    case '&=': variable.set(variable.get() & value); return variable.get()
    case '??=': variable.set(variable.get() ?? value); return variable.get()
    case '&&=': variable.set(variable.get() && value); return variable.get()
    case '||=': variable.set(variable.get() || value); return variable.get()
    /* istanbul ignore next */
    default: throw new SyntaxError(`Unexpected token ${node.operator}`)
  }
}

export function* LogicalExpression(node: acorn.LogicalExpression, scope: Scope) {
  switch (node.operator) {
    case '||':
      return (yield* evaluate(node.left, scope)) || (yield* evaluate(node.right, scope))
    case '&&':
      return (yield* evaluate(node.left, scope)) && (yield* evaluate(node.right, scope))
    case '??':
      return (yield* evaluate(node.left, scope)) ?? (yield* evaluate(node.right, scope))
    default:
      /* istanbul ignore next */
      throw new SyntaxError(`Unexpected token ${node.operator}`)
  }
}

export interface MemberExpressionOptions {
  getObj?: boolean
  getVar?: boolean
}

export function* MemberExpression(
  node: acorn.MemberExpression,
  scope: Scope,
  options: MemberExpressionOptions = {},
) {
  const { getObj = false, getVar = false } = options

  let object: any
  if (node.object.type === 'Super') {
    object = yield* Super(node.object, scope, { getProto: true })
  } else {
    object = yield* evaluate(node.object, scope)
  }

  if (getObj) return object

  let key: string
  let priv: boolean = false

  if (node.computed) {
    key = yield* evaluate(node.property, scope)
  } else if (node.property.type === 'PrivateIdentifier') {
    key = node.property.name
    priv = true
  } else {
    key = (node.property as acorn.Identifier).name
  }

  if (priv) {
    object = object[PRIVATE]
  }

  if (getVar) {
    // left value
    const setter = getSetter(object, key)
    if (node.object.type === 'Super' && setter) {
      // transfer the setter from super to this with a private key
      const thisObject = scope.find('this').get()
      const privateKey = createSymbol(key)
      define(thisObject, privateKey, { set: setter })
      return new Prop(thisObject, privateKey)
    } else {
      return new Prop(object, key)
    }
  } else {
    // right value
    const getter = getGetter(object, key)
    if (node.object.type === 'Super' && getter) {
      const thisObject = scope.find('this').get()
      // if it's optional chaining, check if this ref is null or undefined, so use ==
      if (node.optional && thisObject == null) {
        return undefined
      }
      return getter.call(thisObject)
    } else {
      // if it's optional chaining, check if object is null or undefined, so use ==
      if (node.optional && object == null) {
        return undefined
      }
      return object[key]
    }
  }
}

export function* ConditionalExpression(node: acorn.ConditionalExpression, scope: Scope) {
  return (yield* evaluate(node.test, scope))
    ? (yield* evaluate(node.consequent, scope))
    : (yield* evaluate(node.alternate, scope))
}

export function* CallExpression(node: acorn.CallExpression, scope: Scope) {
  let func: any
  let object: any

  if (node.callee.type === 'MemberExpression') {
    object = yield* MemberExpression(node.callee, scope, { getObj: true })

    // if it's optional chaining, check if object is null or undefined, so use ==
    if (node.callee.optional && object == null) {
      return undefined
    }

    // get key
    let key: string
    let priv: boolean = false

    if (node.callee.computed) {
      key = yield* evaluate(node.callee.property, scope)
    } else if (node.callee.property.type === 'PrivateIdentifier') {
      key = node.callee.property.name
      priv = true
    } else {
      key = (node.callee.property as acorn.Identifier).name
    }

    let obj = object

    if (priv) {
      obj = obj[PRIVATE]
    }

    // right value
    if (node.callee.object.type === 'Super') {
      const thisObject = scope.find('this').get()
      func = obj[key].bind(thisObject)
    } else {
      func = obj[key]
    }

    // if it's optional chaining, check if function is null or undefined, so use ==
    if (node.optional && func == null) {
      return undefined
    }

    if (typeof func !== 'function') {
      throw new TypeError(`${key} is not a function`)
    } else if (func[CLSCTOR]) {
      throw new TypeError(`Class constructor ${key} cannot be invoked without 'new'`)
    }
  } else {
    object = scope.find('this').get()
    func = yield* evaluate(node.callee, scope)

    // if it's optional chaining, check if function is null or undefined, so use ==
    if (node.optional && func == null) {
      return undefined
    }

    if (typeof func !== 'function' || node.callee.type !== 'Super' && func[CLSCTOR]) {
      let name: string
      if (node.callee.type === 'Identifier') {
        name = node.callee.name
      } else {
        try {
          name = JSON.stringify(func)
        } catch (err) {
          name = '' + func
        }
      }
      if (typeof func !== 'function') {
        throw new TypeError(`${name} is not a function`)
      } else {
        throw new TypeError(`Class constructor ${name} cannot be invoked without 'new'`)
      }
    }
  }

  let args: any[] = []
  for (let i = 0; i < node.arguments.length; i++) {
    const arg = node.arguments[i]
    if (arg.type === 'SpreadElement') {
      args = args.concat(yield* SpreadElement(arg, scope))
    } else {
      args.push(yield* evaluate(arg, scope))
    }
  }

  if (node.callee.type === 'Super') {
    const superCall = scope.find(SUPERCALL)
    const construct = superCall.get()
    if (construct === true) {
      throw new ReferenceError('Super constructor may only be called once')
    }
    const inst = callSuper(object, func, args)
    yield* construct(inst)
    scope.find('this').set(inst)
    scope.find(SUPERCALL).set(true)
    return inst
  }

  try {
    return func.apply(object, args)
  } catch (err) {
    if (
      err instanceof TypeError && err.message === 'Illegal invocation'
      && func.toString().indexOf('[native code]') !== -1
    ) {
      // you will get "TypeError: Illegal invocation" if not binding native function with window
      const win = scope.global().find('window').get()
      if (win && win[WINDOW]) {
        return func.apply(win[WINDOW], args)
      }
    }
    throw err
  }
}

export function* NewExpression(node: acorn.NewExpression, scope: Scope) {
  const constructor = yield* evaluate(node.callee, scope)

  if (typeof constructor !== 'function') {
    let name: string
    if (node.callee.type === 'Identifier') {
      name = node.callee.name
    } else {
      try {
        name = JSON.stringify(constructor)
      } catch (err) {
        name = '' + constructor
      }
    }
    throw new TypeError(`${name} is not a constructor`)
  } else if (constructor[NOCTOR]) {
    throw new TypeError(`${constructor.name || '(intermediate value)'} is not a constructor`)
  }

  let args: any[] = []
  for (let i = 0; i < node.arguments.length; i++) {
    const arg = node.arguments[i]
    if (arg.type === 'SpreadElement') {
      args = args.concat(yield* SpreadElement(arg, scope))
    } else {
      args.push(yield* evaluate(arg, scope))
    }
  }

  return new constructor(...args)
}

export function* MetaProperty(node: acorn.MetaProperty, scope: Scope) {
  if (node.meta.name === 'new' && node.property.name === 'target') {
    return scope.find(NEWTARGET).get()
  } else if (node.meta.name === 'import' && node.property.name === 'meta') {
    return { url: '' }
  }
}

export function* SequenceExpression(node: acorn.SequenceExpression, scope: Scope) {
  let result: any
  for (let i = 0; i < node.expressions.length; i++) {
    result = yield* evaluate(node.expressions[i], scope)
  }
  return result
}

export function* ArrowFunctionExpression(node: acorn.ArrowFunctionExpression, scope: Scope) {
  return createFunc(node, scope)
}

export function* TemplateLiteral(node: acorn.TemplateLiteral, scope: Scope) {
  const quasis = node.quasis.slice()
  const expressions = node.expressions.slice()

  let result = ''
  let temEl: acorn.TemplateElement
  let expr: acorn.Expression

  while (temEl = quasis.shift()) {
    result += yield* TemplateElement(temEl, scope)
    expr = expressions.shift()
    if (expr) {
      result += yield* evaluate(expr, scope)
    }
  }

  return result
}

export function* TaggedTemplateExpression(node: acorn.TaggedTemplateExpression, scope: Scope) {
  const tagFunc = yield* evaluate(node.tag, scope)

  const quasis = node.quasi.quasis
  const str = quasis.map(v => v.value.cooked)
  const raw = quasis.map(v => v.value.raw)

  define(str, 'raw', {
    value: freeze(raw)
  })

  const expressions = node.quasi.expressions

  const args = []
  if (expressions) {
    for (let i = 0; i < expressions.length; i++) {
      args.push(yield* evaluate(expressions[i], scope))
    }
  }

  return tagFunc(freeze(str), ...args)
}

export function* TemplateElement(node: acorn.TemplateElement, scope: Scope) {
  return node.value.raw
}

export function* ClassExpression(node: acorn.ClassExpression, scope: Scope) {
  if (node.id && node.id.name) {
    // it's for accessing class expression by its name inside
    // e.g. const a = class b { log() { console.log(b) } }
    const tmpScope = new Scope(scope)
    const klass = yield* createClass(node, tmpScope)
    tmpScope.const(node.id.name, klass)
    return klass
  } else {
    return yield* createClass(node, scope)
  }
}

export interface SuperOptions {
  getProto?: boolean
}

export function* Super(node: acorn.Super, scope: Scope, options: SuperOptions = {}) {
  const { getProto = false } = options
  const superClass = scope.find(SUPER).get()
  return getProto ? superClass.prototype: superClass
}

export interface SpreadOptions {
  spreadProps?: boolean
}

export function* SpreadElement(node: acorn.SpreadElement, scope: Scope, options: SpreadOptions = {}) {
  const result = yield* evaluate(node.argument, scope)
  if (options.spreadProps) {
    return result
  }
  if (typeof Symbol === 'function' && typeof result[Symbol.iterator] !== 'function') {
    throw new TypeError('Spread syntax requires ...iterable[Symbol.iterator] to be a function')
  }
  return [...result]
}

export function* ChainExpression(node: acorn.ChainExpression, scope: Scope) {
  return yield* evaluate(node.expression, scope)
}

export function* ImportExpression(node: acorn.ImportExpression, scope: Scope) {
  const globalScope = scope.global()

  const source = yield* evaluate(node.source, scope)
  const module = globalScope.find(IMPORT + source)
  let value: any
  if (module) {
    const result = module.get()
    if (result) {
      if (typeof result === 'function') {
        value = result()
      } else if (typeof result === 'object') {
        value = result
      }
    }
  }

  if (!value || typeof value !== 'object') {
    return Promise.reject(new TypeError(`Failed to resolve module specifier "${source}"`))
  }

  return Promise.resolve(value)
}

/*<remove>*/
export function* YieldExpression(node: acorn.YieldExpression, scope: Scope): any {
  const res = yield* evaluate(node.argument, scope)
  return node.delegate ? yield* res : yield res
}

export function* AwaitExpression(node: acorn.AwaitExpression, scope: Scope): any {
  AWAIT.RES = yield* evaluate(node.argument, scope)
  return yield AWAIT
}
/*</remove>*/

1	import { define, freeze, getGetter, getSetter, createSymbol, assign, getDptor, callSuper, WINDOW } from '../share/util'
2	import { SUPER, NOCTOR, AWAIT, CLSCTOR, NEWTARGET, SUPERCALL, PRIVATE, IMPORT } from '../share/const'
3	import { pattern, createFunc, createClass } from './helper'
4	import { Variable, Prop } from '../scope/variable'
5	import { Identifier } from './identifier'
6	import { Literal } from './literal'
7	import * as acorn from 'acorn'
8	import Scope from '../scope'
9	import evaluate from '.'
10
11	export function* ThisExpression(node: acorn.ThisExpression, scope: Scope) {
12	const superCall = scope.find(SUPERCALL)	8✔
13	if (superCall && superCall.get() !== true) {	8!
14	throw new ReferenceError('Must call super constructor in derived class '	×
15	+ 'before accessing \'this\' or returning from derived constructor')
16	} else {
17	return scope.find('this').get()	8✔
18	}
19	}
20
21	export function* ArrayExpression(node: acorn.ArrayExpression, scope: Scope) {
22	let results: any[] = []	64✔
23	for (let i = 0; i < node.elements.length; i++) {	64✔
24	const item = node.elements[i]	152✔
25	if (item.type === 'SpreadElement') {	152✔
26	results = results.concat(yield* SpreadElement(item, scope))	×
27	} else {
28	results.push(yield* evaluate(item, scope))	152✔
29	}
30	}
31	return results	64✔
32	}
33
34	export function* ObjectExpression(node: acorn.ObjectExpression, scope: Scope) {
35	const object: { [key: string]: any } = {}	24✔
36	for (let i = 0; i < node.properties.length; i++) {	24✔
37	const property = node.properties[i]	34✔
38	if (property.type === 'SpreadElement') {	34✔
39	assign(object, yield* SpreadElement(property, scope, { spreadProps: true }))	×
40	} else {
41	let key: string
42	const propKey = property.key	34✔
43	if (property.computed) {	34✔
44	key = yield* evaluate(propKey, scope)	×
45	} else {
46	if (propKey.type === 'Identifier') {	34✔
47	key = propKey.name	28✔
48	} else {
49	key = '' + (yield* Literal(propKey as acorn.Literal, scope))	6✔
50	}
51	}
52
53	const value = yield* evaluate(property.value, scope)	34✔
54
55	const propKind = property.kind	34✔
56	if (propKind === 'init') {	34✔
57	object[key] = value	30✔
58	} else if (propKind === 'get') {	4✔
59	const oriDptor = getDptor(object, key)	2✔
60	define(object, key, {	2✔
61	get: value,
62	set: oriDptor && oriDptor.set,	1!
63	enumerable: true,
64	configurable: true
65	})
66	} else { // propKind === 'set'
67	const oriDptor = getDptor(object, key)	2✔
68	define(object, key, {	2✔
69	get: oriDptor && oriDptor.get,	2✔
70	set: value,
71	enumerable: true,
72	configurable: true
73	})
74	}
75	}
76	}
77	return object	24✔
78	}
79
80	export function* FunctionExpression(node: acorn.FunctionExpression, scope: Scope) {
81	if (node.id && node.id.name) {	26!
82	// it's for accessing function expression by its name inside
83	// e.g. const a = function b() { console.log(b) }
84	const tmpScope = new Scope(scope)	×
85	const func = createFunc(node, tmpScope)	×
86	tmpScope.const(node.id.name, func)	×
87	return func	×
88	} else {
89	return createFunc(node, scope)	26✔
90	}
91	}
92
93	export function* UnaryExpression(node: acorn.UnaryExpression, scope: Scope) {
94	const arg = node.argument	20✔
95	switch (node.operator) {	20✔
96	case '+': return +(yield* evaluate(arg, scope))	2✔
97	case '-': return -(yield* evaluate(arg, scope))	2✔
98	case '!': return !(yield* evaluate(arg, scope))	6✔
99	case '~': return ~(yield* evaluate(arg, scope))	2✔
100	case 'void': return void (yield* evaluate(arg, scope))	2✔
101	case 'typeof':
102	if (arg.type === 'Identifier') {	4✔
103	return typeof (yield* Identifier(arg, scope, { throwErr: false }))	2✔
104	} else {
105	return typeof (yield* evaluate(arg, scope))	2✔
106	}
107	case 'delete':
108	if (arg.type === 'MemberExpression') {	2!
109	const variable: Prop = yield* MemberExpression(arg, scope, { getVar: true })	2✔
110	return variable.del()	2✔
111	} else if (arg.type === 'Identifier') {	×
112	throw new SyntaxError('Delete of an unqualified identifier in strict mode')	×
113	} else {
114	yield* evaluate(arg, scope)	×
115	return true	×
116	}
117	/* istanbul ignore next */
118	default: throw new SyntaxError(`Unexpected token ${node.operator}`)
119	}
120	}
121
122	export function* UpdateExpression(node: acorn.UpdateExpression, scope: Scope) {
123	const arg = node.argument	8✔
124
125	let variable: Variable
126	if (arg.type === 'Identifier') {	8!
127	variable = yield* Identifier(arg, scope, { getVar: true })	8✔
128	} else if (arg.type === 'MemberExpression') {	×
129	variable = yield* MemberExpression(arg, scope, { getVar: true })	×
130	} else {
131	/* istanbul ignore next */
132	throw new SyntaxError('Unexpected token')
133	}
134
135	const value = variable.get()	8✔
136	if (node.operator === '++') {	8!
137	variable.set(value + 1)	8✔
138	return node.prefix ? variable.get() : value	8!
139	} else if (node.operator === '--') {	×
140	variable.set(value - 1)	×
141	return node.prefix ? variable.get() : value	×
142	} else {
143	/* istanbul ignore next */
144	throw new SyntaxError(`Unexpected token ${node.operator}`)
145	}
146	}
147
148	export function* BinaryExpression(node: acorn.BinaryExpression, scope: Scope) {
149	let left: any
150	let right: any
151
152	if (node.left.type === 'PrivateIdentifier') {	54!
153	left = node.left.name	×
154	right = yield* evaluate(node.right, scope)	×
155	right = right[PRIVATE] \|\| {} // compatible with checking by "#private in object"	×
156	} else {
157	left = yield* evaluate(node.left, scope)	54✔
158	right = yield* evaluate(node.right, scope)	54✔
159	}
160
161	switch (node.operator) {	54✔
162	case '==': return left == right	2✔
163	case '!=': return left != right	2✔
164	case '===': return left === right	2✔
165	case '!==': return left !== right	2✔
166	case '<': return left < right	10✔
167	case '<=': return left <= right	2✔
168	case '>': return left > right	2✔
169	case '>=': return left >= right	2✔
170	case '<<': return left << right	2✔
171	case '>>': return left >> right	2✔
172	case '>>>': return left >>> right	2✔
173	case '+': return left + right	2✔
174	case '-': return left - right	2✔
175	case '': return left right	2✔
176	case '': return left right	2✔
177	case '/': return left / right	2✔
178	case '%': return left % right	2✔
179	case '\|': return left \| right	2✔
180	case '^': return left ^ right	2✔
181	case '&': return left & right	2✔
182	case 'in': return left in right	2✔
183	case 'instanceof': return left instanceof right	4✔
184	/* istanbul ignore next */
185	default: throw new SyntaxError(`Unexpected token ${node.operator}`)
186	}
187	}
188
189	export function* AssignmentExpression(node: acorn.AssignmentExpression, scope: Scope) {
190	const left = node.left	158✔
191	let variable: Variable
192	if (left.type === 'Identifier') {	158!
193	variable = yield* Identifier(left, scope, { getVar: true, throwErr: false })	×
194	if (!variable) {	×
195	const win = scope.global().find('window').get()	×
196	variable = new Prop(win, left.name)	×
197	}
198	} else if (left.type === 'MemberExpression') {	158!
199	variable = yield* MemberExpression(left, scope, { getVar: true })	158✔
200	} else {
201	const value = yield* evaluate(node.right, scope)	×
202	return yield* pattern(left, scope, { feed: value })	×
203	}
204
205	const value = yield* evaluate(node.right, scope)	158✔
206	switch (node.operator) {	156✔
207	case '=': variable.set(value); return variable.get()	126✔
208	case '+=': variable.set(variable.get() + value); return variable.get()	2✔
209	case '-=': variable.set(variable.get() - value); return variable.get()	2✔
210	case '=': variable.set(variable.get() value); return variable.get()	2✔
211	case '/=': variable.set(variable.get() / value); return variable.get()	2✔
212	case '%=': variable.set(variable.get() % value); return variable.get()	2✔
213	case '=': variable.set(variable.get() value); return variable.get()	2✔
214	case '<<=': variable.set(variable.get() << value); return variable.get()	2✔
215	case '>>=': variable.set(variable.get() >> value); return variable.get()	2✔
216	case '>>>=': variable.set(variable.get() >>> value); return variable.get()	2✔
217	case '\|=': variable.set(variable.get() \| value); return variable.get()	2✔
218	case '^=': variable.set(variable.get() ^ value); return variable.get()	2✔
219	case '&=': variable.set(variable.get() & value); return variable.get()	2✔
220	case '??=': variable.set(variable.get() ?? value); return variable.get()	2!
221	case '&&=': variable.set(variable.get() && value); return variable.get()	2!
222	case '\|\|=': variable.set(variable.get() \|\| value); return variable.get()	2✔
223	/* istanbul ignore next */
224	default: throw new SyntaxError(`Unexpected token ${node.operator}`)
225	}
226	}
227
228	export function* LogicalExpression(node: acorn.LogicalExpression, scope: Scope) {
229	switch (node.operator) {	×
230	case '\|\|':
231	return (yield* evaluate(node.left, scope)) \|\| (yield* evaluate(node.right, scope))	×
232	case '&&':
233	return (yield* evaluate(node.left, scope)) && (yield* evaluate(node.right, scope))	×
234	case '??':
235	return (yield* evaluate(node.left, scope)) ?? (yield* evaluate(node.right, scope))	×
236	default:
237	/* istanbul ignore next */
238	throw new SyntaxError(`Unexpected token ${node.operator}`)
239	}
240	}
241
242	export interface MemberExpressionOptions {
243	getObj?: boolean
244	getVar?: boolean
245	}
246
247	export function* MemberExpression(
248	node: acorn.MemberExpression,
249	scope: Scope,
250	options: MemberExpressionOptions = {},	32✔
251	) {
252	const { getObj = false, getVar = false } = options	388✔
253
254	let object: any
255	if (node.object.type === 'Super') {	388!
256	object = yield* Super(node.object, scope, { getProto: true })	×
257	} else {
258	object = yield* evaluate(node.object, scope)	388✔
259	}
260
261	if (getObj) return object	388✔
262
263	let key: string
264	let priv: boolean = false	224✔
265
266	if (node.computed) {	224!
267	key = yield* evaluate(node.property, scope)	×
268	} else if (node.property.type === 'PrivateIdentifier') {	224!
269	key = node.property.name	×
270	priv = true	×
271	} else {
272	key = (node.property as acorn.Identifier).name	224✔
273	}
274
275	if (priv) {	224!
276	object = object[PRIVATE]	×
277	}
278
279	if (getVar) {	224✔
280	// left value
281	const setter = getSetter(object, key)	160✔
282	if (node.object.type === 'Super' && setter) {	160!
283	// transfer the setter from super to this with a private key
284	const thisObject = scope.find('this').get()	×
285	const privateKey = createSymbol(key)	×
286	define(thisObject, privateKey, { set: setter })	×
287	return new Prop(thisObject, privateKey)	×
288	} else {
289	return new Prop(object, key)	160✔
290	}
291	} else {
292	// right value
293	const getter = getGetter(object, key)	64✔
294	if (node.object.type === 'Super' && getter) {	64!
295	const thisObject = scope.find('this').get()	×
296	// if it's optional chaining, check if this ref is null or undefined, so use ==
297	if (node.optional && thisObject == null) {	×
298	return undefined	×
299	}
300	return getter.call(thisObject)	×
301	} else {
302	// if it's optional chaining, check if object is null or undefined, so use ==
303	if (node.optional && object == null) {	64!
304	return undefined	×
305	}
306	return object[key]	64✔
307	}
308	}
309	}
310
311	export function* ConditionalExpression(node: acorn.ConditionalExpression, scope: Scope) {
312	return (yield* evaluate(node.test, scope))	×
313	? (yield* evaluate(node.consequent, scope))
314	: (yield* evaluate(node.alternate, scope))
315	}
316
317	export function* CallExpression(node: acorn.CallExpression, scope: Scope) {
318	let func: any
319	let object: any
320
321	if (node.callee.type === 'MemberExpression') {	302✔
322	object = yield* MemberExpression(node.callee, scope, { getObj: true })	164✔
323
324	// if it's optional chaining, check if object is null or undefined, so use ==
325	if (node.callee.optional && object == null) {	164!
326	return undefined	×
327	}
328
329	// get key
330	let key: string
331	let priv: boolean = false	164✔
332
333	if (node.callee.computed) {	164!
334	key = yield* evaluate(node.callee.property, scope)	×
335	} else if (node.callee.property.type === 'PrivateIdentifier') {	164!
336	key = node.callee.property.name	×
337	priv = true	×
338	} else {
339	key = (node.callee.property as acorn.Identifier).name	164✔
340	}
341
342	let obj = object	164✔
343
344	if (priv) {	164!
345	obj = obj[PRIVATE]	×
346	}
347
348	// right value
349	if (node.callee.object.type === 'Super') {	164!
350	const thisObject = scope.find('this').get()	×
351	func = obj[key].bind(thisObject)	×
352	} else {
353	func = obj[key]	164✔
354	}
355
356	// if it's optional chaining, check if function is null or undefined, so use ==
357	if (node.optional && func == null) {	164!
358	return undefined	×
359	}
360
361	if (typeof func !== 'function') {	164!
362	throw new TypeError(`${key} is not a function`)	×
363	} else if (func[CLSCTOR]) {	164!
364	throw new TypeError(`Class constructor ${key} cannot be invoked without 'new'`)	×
365	}
366	} else {
367	object = scope.find('this').get()	138✔
368	func = yield* evaluate(node.callee, scope)	138✔
369
370	// if it's optional chaining, check if function is null or undefined, so use ==
371	if (node.optional && func == null) {	138!
372	return undefined	×
373	}
374
375	if (typeof func !== 'function' \|\| node.callee.type !== 'Super' && func[CLSCTOR]) {	138!
376	let name: string
377	if (node.callee.type === 'Identifier') {	×
378	name = node.callee.name	×
379	} else {
380	try {	×
381	name = JSON.stringify(func)	×
382	} catch (err) {
383	name = '' + func	×
384	}
385	}
386	if (typeof func !== 'function') {	×
387	throw new TypeError(`${name} is not a function`)	×
388	} else {
389	throw new TypeError(`Class constructor ${name} cannot be invoked without 'new'`)	×
390	}
391	}
392	}
393
394	let args: any[] = []	302✔
395	for (let i = 0; i < node.arguments.length; i++) {	302✔
396	const arg = node.arguments[i]	278✔
397	if (arg.type === 'SpreadElement') {	278!
398	args = args.concat(yield* SpreadElement(arg, scope))	×
399	} else {
400	args.push(yield* evaluate(arg, scope))	278✔
401	}
402	}
403
404	if (node.callee.type === 'Super') {	298!
405	const superCall = scope.find(SUPERCALL)	×
NEW 406	const construct = superCall.get()	×
NEW 407	if (construct === true) {	×
UNCOV 408	throw new ReferenceError('Super constructor may only be called once')	×
409	}
NEW 410	const inst = callSuper(object, func, args)	×
NEW 411	yield* construct(inst)	×
NEW 412	scope.find('this').set(inst)	×
NEW 413	scope.find(SUPERCALL).set(true)	×
NEW 414	return inst	×
415	}
416
417	try {	298✔
418	return func.apply(object, args)	298✔
419	} catch (err) {
420	if (	2!
421	err instanceof TypeError && err.message === 'Illegal invocation'	1!
422	&& func.toString().indexOf('[native code]') !== -1
423	) {
424	// you will get "TypeError: Illegal invocation" if not binding native function with window
425	const win = scope.global().find('window').get()	×
426	if (win && win[WINDOW]) {	×
427	return func.apply(win[WINDOW], args)	×
428	}
429	}
430	throw err	2✔
431	}
432	}
433
434	export function* NewExpression(node: acorn.NewExpression, scope: Scope) {
435	const constructor = yield* evaluate(node.callee, scope)	4✔
436
437	if (typeof constructor !== 'function') {	4!
438	let name: string
439	if (node.callee.type === 'Identifier') {	×
440	name = node.callee.name	×
441	} else {
442	try {	×
443	name = JSON.stringify(constructor)	×
444	} catch (err) {
445	name = '' + constructor	×
446	}
447	}
448	throw new TypeError(`${name} is not a constructor`)	×
449	} else if (constructor[NOCTOR]) {	4!
450	throw new TypeError(`${constructor.name \|\| '(intermediate value)'} is not a constructor`)	×
451	}
452
453	let args: any[] = []	4✔
454	for (let i = 0; i < node.arguments.length; i++) {	4✔
455	const arg = node.arguments[i]	2✔
456	if (arg.type === 'SpreadElement') {	2!
457	args = args.concat(yield* SpreadElement(arg, scope))	×
458	} else {
459	args.push(yield* evaluate(arg, scope))	2✔
460	}
461	}
462
463	return new constructor(...args)	4✔
464	}
465
466	export function* MetaProperty(node: acorn.MetaProperty, scope: Scope) {
467	if (node.meta.name === 'new' && node.property.name === 'target') {	×
468	return scope.find(NEWTARGET).get()	×
469	} else if (node.meta.name === 'import' && node.property.name === 'meta') {	×
470	return { url: '' }	×
471	}
472	}
473
474	export function* SequenceExpression(node: acorn.SequenceExpression, scope: Scope) {
475	let result: any
476	for (let i = 0; i < node.expressions.length; i++) {	×
477	result = yield* evaluate(node.expressions[i], scope)	×
478	}
479	return result	×
480	}
481
482	export function* ArrowFunctionExpression(node: acorn.ArrowFunctionExpression, scope: Scope) {
483	return createFunc(node, scope)	6✔
484	}
485
486	export function* TemplateLiteral(node: acorn.TemplateLiteral, scope: Scope) {
487	const quasis = node.quasis.slice()	×
488	const expressions = node.expressions.slice()	×
489
490	let result = ''	×
491	let temEl: acorn.TemplateElement
492	let expr: acorn.Expression
493
494	while (temEl = quasis.shift()) {	×
495	result += yield* TemplateElement(temEl, scope)	×
496	expr = expressions.shift()	×
497	if (expr) {	×
498	result += yield* evaluate(expr, scope)	×
499	}
500	}
501
502	return result	×
503	}
504
505	export function* TaggedTemplateExpression(node: acorn.TaggedTemplateExpression, scope: Scope) {
506	const tagFunc = yield* evaluate(node.tag, scope)	×
507
508	const quasis = node.quasi.quasis	×
509	const str = quasis.map(v => v.value.cooked)	×
510	const raw = quasis.map(v => v.value.raw)	×
511
512	define(str, 'raw', {	×
513	value: freeze(raw)
514	})
515
516	const expressions = node.quasi.expressions	×
517
518	const args = []	×
519	if (expressions) {	×
520	for (let i = 0; i < expressions.length; i++) {	×
521	args.push(yield* evaluate(expressions[i], scope))	×
522	}
523	}
524
525	return tagFunc(freeze(str), ...args)	×
526	}
527
528	export function* TemplateElement(node: acorn.TemplateElement, scope: Scope) {
529	return node.value.raw	×
530	}
531
532	export function* ClassExpression(node: acorn.ClassExpression, scope: Scope) {
533	if (node.id && node.id.name) {	×
534	// it's for accessing class expression by its name inside
535	// e.g. const a = class b { log() { console.log(b) } }
536	const tmpScope = new Scope(scope)	×
537	const klass = yield* createClass(node, tmpScope)	×
538	tmpScope.const(node.id.name, klass)	×
539	return klass	×
540	} else {
541	return yield* createClass(node, scope)	×
542	}
543	}
544
545	export interface SuperOptions {
546	getProto?: boolean
547	}
548
549	export function* Super(node: acorn.Super, scope: Scope, options: SuperOptions = {}) {	×
550	const { getProto = false } = options	×
551	const superClass = scope.find(SUPER).get()	×
552	return getProto ? superClass.prototype: superClass	×
553	}
554
555	export interface SpreadOptions {
556	spreadProps?: boolean
557	}
558
559	export function* SpreadElement(node: acorn.SpreadElement, scope: Scope, options: SpreadOptions = {}) {	×
560	const result = yield* evaluate(node.argument, scope)	×
561	if (options.spreadProps) {	×
562	return result	×
563	}
564	if (typeof Symbol === 'function' && typeof result[Symbol.iterator] !== 'function') {	×
565	throw new TypeError('Spread syntax requires ...iterable[Symbol.iterator] to be a function')	×
566	}
567	return [...result]	×
568	}
569
570	export function* ChainExpression(node: acorn.ChainExpression, scope: Scope) {
571	return yield* evaluate(node.expression, scope)	×
572	}
573
574	export function* ImportExpression(node: acorn.ImportExpression, scope: Scope) {
575	const globalScope = scope.global()	4✔
576
577	const source = yield* evaluate(node.source, scope)	4✔
578	const module = globalScope.find(IMPORT + source)	4✔
579	let value: any
580	if (module) {	4!
581	const result = module.get()	4✔
582	if (result) {	4!
583	if (typeof result === 'function') {	4!
584	value = result()	4✔
585	} else if (typeof result === 'object') {	×
586	value = result	×
587	}
588	}
589	}
590
591	if (!value \|\| typeof value !== 'object') {	4!
592	return Promise.reject(new TypeError(`Failed to resolve module specifier "${source}"`))	×
593	}
594
595	return Promise.resolve(value)	4✔
596	}
597
598	/<remove>/
599	export function* YieldExpression(node: acorn.YieldExpression, scope: Scope): any {
600	const res = yield* evaluate(node.argument, scope)	42✔
601	return node.delegate ? yield* res : yield res	40✔
602	}
603
604	export function* AwaitExpression(node: acorn.AwaitExpression, scope: Scope): any {
605	AWAIT.RES = yield* evaluate(node.argument, scope)	44✔
606	return yield AWAIT	42✔
607	}
608	/</remove>/

Siubaak / sval / 13744972796

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous