statement.go 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987
  1. package parser
  2. import (
  3. "encoding/base64"
  4. "fmt"
  5. "os"
  6. "strings"
  7. "github.com/dop251/goja/ast"
  8. "github.com/dop251/goja/file"
  9. "github.com/dop251/goja/token"
  10. "github.com/go-sourcemap/sourcemap"
  11. )
  12. func (self *_parser) parseBlockStatement() *ast.BlockStatement {
  13. node := &ast.BlockStatement{}
  14. node.LeftBrace = self.expect(token.LEFT_BRACE)
  15. node.List = self.parseStatementList()
  16. node.RightBrace = self.expect(token.RIGHT_BRACE)
  17. return node
  18. }
  19. func (self *_parser) parseEmptyStatement() ast.Statement {
  20. idx := self.expect(token.SEMICOLON)
  21. return &ast.EmptyStatement{Semicolon: idx}
  22. }
  23. func (self *_parser) parseStatementList() (list []ast.Statement) {
  24. for self.token != token.RIGHT_BRACE && self.token != token.EOF {
  25. self.scope.allowLet = true
  26. list = append(list, self.parseStatement())
  27. }
  28. return
  29. }
  30. func (self *_parser) parseStatement() ast.Statement {
  31. if self.token == token.EOF {
  32. self.errorUnexpectedToken(self.token)
  33. return &ast.BadStatement{From: self.idx, To: self.idx + 1}
  34. }
  35. switch self.token {
  36. case token.SEMICOLON:
  37. return self.parseEmptyStatement()
  38. case token.LEFT_BRACE:
  39. return self.parseBlockStatement()
  40. case token.IF:
  41. return self.parseIfStatement()
  42. case token.DO:
  43. return self.parseDoWhileStatement()
  44. case token.WHILE:
  45. return self.parseWhileStatement()
  46. case token.FOR:
  47. return self.parseForOrForInStatement()
  48. case token.BREAK:
  49. return self.parseBreakStatement()
  50. case token.CONTINUE:
  51. return self.parseContinueStatement()
  52. case token.DEBUGGER:
  53. return self.parseDebuggerStatement()
  54. case token.WITH:
  55. return self.parseWithStatement()
  56. case token.VAR:
  57. return self.parseVariableStatement()
  58. case token.LET:
  59. tok := self.peek()
  60. if tok == token.LEFT_BRACKET || self.scope.allowLet && (token.IsId(tok) || tok == token.LEFT_BRACE) {
  61. return self.parseLexicalDeclaration(self.token)
  62. }
  63. self.insertSemicolon = true
  64. case token.CONST:
  65. return self.parseLexicalDeclaration(self.token)
  66. case token.FUNCTION:
  67. return &ast.FunctionDeclaration{
  68. Function: self.parseFunction(true),
  69. }
  70. case token.CLASS:
  71. return &ast.ClassDeclaration{
  72. Class: self.parseClass(true),
  73. }
  74. case token.SWITCH:
  75. return self.parseSwitchStatement()
  76. case token.RETURN:
  77. return self.parseReturnStatement()
  78. case token.THROW:
  79. return self.parseThrowStatement()
  80. case token.TRY:
  81. return self.parseTryStatement()
  82. }
  83. expression := self.parseExpression()
  84. if identifier, isIdentifier := expression.(*ast.Identifier); isIdentifier && self.token == token.COLON {
  85. // LabelledStatement
  86. colon := self.idx
  87. self.next() // :
  88. label := identifier.Name
  89. for _, value := range self.scope.labels {
  90. if label == value {
  91. self.error(identifier.Idx0(), "Label '%s' already exists", label)
  92. }
  93. }
  94. self.scope.labels = append(self.scope.labels, label) // Push the label
  95. self.scope.allowLet = false
  96. statement := self.parseStatement()
  97. self.scope.labels = self.scope.labels[:len(self.scope.labels)-1] // Pop the label
  98. return &ast.LabelledStatement{
  99. Label: identifier,
  100. Colon: colon,
  101. Statement: statement,
  102. }
  103. }
  104. self.optionalSemicolon()
  105. return &ast.ExpressionStatement{
  106. Expression: expression,
  107. }
  108. }
  109. func (self *_parser) parseTryStatement() ast.Statement {
  110. node := &ast.TryStatement{
  111. Try: self.expect(token.TRY),
  112. Body: self.parseBlockStatement(),
  113. }
  114. if self.token == token.CATCH {
  115. catch := self.idx
  116. self.next()
  117. var parameter ast.BindingTarget
  118. if self.token == token.LEFT_PARENTHESIS {
  119. self.next()
  120. parameter = self.parseBindingTarget()
  121. self.expect(token.RIGHT_PARENTHESIS)
  122. }
  123. node.Catch = &ast.CatchStatement{
  124. Catch: catch,
  125. Parameter: parameter,
  126. Body: self.parseBlockStatement(),
  127. }
  128. }
  129. if self.token == token.FINALLY {
  130. self.next()
  131. node.Finally = self.parseBlockStatement()
  132. }
  133. if node.Catch == nil && node.Finally == nil {
  134. self.error(node.Try, "Missing catch or finally after try")
  135. return &ast.BadStatement{From: node.Try, To: node.Body.Idx1()}
  136. }
  137. return node
  138. }
  139. func (self *_parser) parseFunctionParameterList() *ast.ParameterList {
  140. opening := self.expect(token.LEFT_PARENTHESIS)
  141. var list []*ast.Binding
  142. var rest ast.Expression
  143. for self.token != token.RIGHT_PARENTHESIS && self.token != token.EOF {
  144. if self.token == token.ELLIPSIS {
  145. self.next()
  146. rest = self.reinterpretAsDestructBindingTarget(self.parseAssignmentExpression())
  147. break
  148. }
  149. self.parseVariableDeclaration(&list)
  150. if self.token != token.RIGHT_PARENTHESIS {
  151. self.expect(token.COMMA)
  152. }
  153. }
  154. closing := self.expect(token.RIGHT_PARENTHESIS)
  155. return &ast.ParameterList{
  156. Opening: opening,
  157. List: list,
  158. Rest: rest,
  159. Closing: closing,
  160. }
  161. }
  162. func (self *_parser) parseFunction(declaration bool) *ast.FunctionLiteral {
  163. node := &ast.FunctionLiteral{
  164. Function: self.expect(token.FUNCTION),
  165. }
  166. self.tokenToBindingId()
  167. var name *ast.Identifier
  168. if self.token == token.IDENTIFIER {
  169. name = self.parseIdentifier()
  170. } else if declaration {
  171. // Use expect error handling
  172. self.expect(token.IDENTIFIER)
  173. }
  174. node.Name = name
  175. node.ParameterList = self.parseFunctionParameterList()
  176. node.Body, node.DeclarationList = self.parseFunctionBlock()
  177. node.Source = self.slice(node.Idx0(), node.Idx1())
  178. return node
  179. }
  180. func (self *_parser) parseFunctionBlock() (body *ast.BlockStatement, declarationList []*ast.VariableDeclaration) {
  181. self.openScope()
  182. inFunction := self.scope.inFunction
  183. self.scope.inFunction = true
  184. defer func() {
  185. self.scope.inFunction = inFunction
  186. self.closeScope()
  187. }()
  188. body = self.parseBlockStatement()
  189. declarationList = self.scope.declarationList
  190. return
  191. }
  192. func (self *_parser) parseArrowFunctionBody() (ast.ConciseBody, []*ast.VariableDeclaration) {
  193. if self.token == token.LEFT_BRACE {
  194. return self.parseFunctionBlock()
  195. }
  196. return &ast.ExpressionBody{
  197. Expression: self.parseAssignmentExpression(),
  198. }, nil
  199. }
  200. func (self *_parser) parseClass(declaration bool) *ast.ClassLiteral {
  201. if !self.scope.allowLet && self.token == token.CLASS {
  202. self.errorUnexpectedToken(token.CLASS)
  203. }
  204. node := &ast.ClassLiteral{
  205. Class: self.expect(token.CLASS),
  206. }
  207. self.tokenToBindingId()
  208. var name *ast.Identifier
  209. if self.token == token.IDENTIFIER {
  210. name = self.parseIdentifier()
  211. } else if declaration {
  212. // Use expect error handling
  213. self.expect(token.IDENTIFIER)
  214. }
  215. node.Name = name
  216. if self.token != token.LEFT_BRACE {
  217. self.expect(token.EXTENDS)
  218. node.SuperClass = self.parseLeftHandSideExpressionAllowCall()
  219. }
  220. self.expect(token.LEFT_BRACE)
  221. for self.token != token.RIGHT_BRACE && self.token != token.EOF {
  222. if self.token == token.SEMICOLON {
  223. self.next()
  224. continue
  225. }
  226. start := self.idx
  227. static := false
  228. if self.token == token.STATIC {
  229. switch self.peek() {
  230. case token.ASSIGN, token.SEMICOLON, token.RIGHT_BRACE, token.LEFT_PARENTHESIS:
  231. // treat as identifier
  232. default:
  233. self.next()
  234. if self.token == token.LEFT_BRACE {
  235. b := &ast.ClassStaticBlock{
  236. Static: start,
  237. }
  238. b.Block, b.DeclarationList = self.parseFunctionBlock()
  239. b.Source = self.slice(b.Block.LeftBrace, b.Block.Idx1())
  240. node.Body = append(node.Body, b)
  241. continue
  242. }
  243. static = true
  244. }
  245. }
  246. var kind ast.PropertyKind
  247. methodBodyStart := self.idx
  248. if self.literal == "get" || self.literal == "set" {
  249. if self.peek() != token.LEFT_PARENTHESIS {
  250. if self.literal == "get" {
  251. kind = ast.PropertyKindGet
  252. } else {
  253. kind = ast.PropertyKindSet
  254. }
  255. self.next()
  256. }
  257. }
  258. _, keyName, value, tkn := self.parseObjectPropertyKey()
  259. if value == nil {
  260. continue
  261. }
  262. computed := tkn == token.ILLEGAL
  263. _, private := value.(*ast.PrivateIdentifier)
  264. if static && !private && keyName == "prototype" {
  265. self.error(value.Idx0(), "Classes may not have a static property named 'prototype'")
  266. }
  267. if kind == "" && self.token == token.LEFT_PARENTHESIS {
  268. kind = ast.PropertyKindMethod
  269. }
  270. if kind != "" {
  271. // method
  272. if keyName == "constructor" {
  273. if !computed && !static && kind != ast.PropertyKindMethod {
  274. self.error(value.Idx0(), "Class constructor may not be an accessor")
  275. } else if private {
  276. self.error(value.Idx0(), "Class constructor may not be a private method")
  277. }
  278. }
  279. md := &ast.MethodDefinition{
  280. Idx: start,
  281. Key: value,
  282. Kind: kind,
  283. Body: self.parseMethodDefinition(methodBodyStart, kind),
  284. Static: static,
  285. Computed: computed,
  286. }
  287. node.Body = append(node.Body, md)
  288. } else {
  289. // field
  290. isCtor := !computed && keyName == "constructor"
  291. if !isCtor {
  292. if name, ok := value.(*ast.PrivateIdentifier); ok {
  293. isCtor = name.Name == "constructor"
  294. }
  295. }
  296. if isCtor {
  297. self.error(value.Idx0(), "Classes may not have a field named 'constructor'")
  298. }
  299. var initializer ast.Expression
  300. if self.token == token.ASSIGN {
  301. self.next()
  302. initializer = self.parseExpression()
  303. }
  304. if !self.implicitSemicolon && self.token != token.SEMICOLON && self.token != token.RIGHT_BRACE {
  305. self.errorUnexpectedToken(self.token)
  306. break
  307. }
  308. node.Body = append(node.Body, &ast.FieldDefinition{
  309. Idx: start,
  310. Key: value,
  311. Initializer: initializer,
  312. Static: static,
  313. Computed: computed,
  314. })
  315. }
  316. }
  317. node.RightBrace = self.expect(token.RIGHT_BRACE)
  318. node.Source = self.slice(node.Class, node.RightBrace+1)
  319. return node
  320. }
  321. func (self *_parser) parseDebuggerStatement() ast.Statement {
  322. idx := self.expect(token.DEBUGGER)
  323. node := &ast.DebuggerStatement{
  324. Debugger: idx,
  325. }
  326. self.semicolon()
  327. return node
  328. }
  329. func (self *_parser) parseReturnStatement() ast.Statement {
  330. idx := self.expect(token.RETURN)
  331. if !self.scope.inFunction {
  332. self.error(idx, "Illegal return statement")
  333. self.nextStatement()
  334. return &ast.BadStatement{From: idx, To: self.idx}
  335. }
  336. node := &ast.ReturnStatement{
  337. Return: idx,
  338. }
  339. if !self.implicitSemicolon && self.token != token.SEMICOLON && self.token != token.RIGHT_BRACE && self.token != token.EOF {
  340. node.Argument = self.parseExpression()
  341. }
  342. self.semicolon()
  343. return node
  344. }
  345. func (self *_parser) parseThrowStatement() ast.Statement {
  346. idx := self.expect(token.THROW)
  347. if self.implicitSemicolon {
  348. if self.chr == -1 { // Hackish
  349. self.error(idx, "Unexpected end of input")
  350. } else {
  351. self.error(idx, "Illegal newline after throw")
  352. }
  353. self.nextStatement()
  354. return &ast.BadStatement{From: idx, To: self.idx}
  355. }
  356. node := &ast.ThrowStatement{
  357. Throw: idx,
  358. Argument: self.parseExpression(),
  359. }
  360. self.semicolon()
  361. return node
  362. }
  363. func (self *_parser) parseSwitchStatement() ast.Statement {
  364. self.expect(token.SWITCH)
  365. self.expect(token.LEFT_PARENTHESIS)
  366. node := &ast.SwitchStatement{
  367. Discriminant: self.parseExpression(),
  368. Default: -1,
  369. }
  370. self.expect(token.RIGHT_PARENTHESIS)
  371. self.expect(token.LEFT_BRACE)
  372. inSwitch := self.scope.inSwitch
  373. self.scope.inSwitch = true
  374. defer func() {
  375. self.scope.inSwitch = inSwitch
  376. }()
  377. for index := 0; self.token != token.EOF; index++ {
  378. if self.token == token.RIGHT_BRACE {
  379. self.next()
  380. break
  381. }
  382. clause := self.parseCaseStatement()
  383. if clause.Test == nil {
  384. if node.Default != -1 {
  385. self.error(clause.Case, "Already saw a default in switch")
  386. }
  387. node.Default = index
  388. }
  389. node.Body = append(node.Body, clause)
  390. }
  391. return node
  392. }
  393. func (self *_parser) parseWithStatement() ast.Statement {
  394. self.expect(token.WITH)
  395. self.expect(token.LEFT_PARENTHESIS)
  396. node := &ast.WithStatement{
  397. Object: self.parseExpression(),
  398. }
  399. self.expect(token.RIGHT_PARENTHESIS)
  400. self.scope.allowLet = false
  401. node.Body = self.parseStatement()
  402. return node
  403. }
  404. func (self *_parser) parseCaseStatement() *ast.CaseStatement {
  405. node := &ast.CaseStatement{
  406. Case: self.idx,
  407. }
  408. if self.token == token.DEFAULT {
  409. self.next()
  410. } else {
  411. self.expect(token.CASE)
  412. node.Test = self.parseExpression()
  413. }
  414. self.expect(token.COLON)
  415. for {
  416. if self.token == token.EOF ||
  417. self.token == token.RIGHT_BRACE ||
  418. self.token == token.CASE ||
  419. self.token == token.DEFAULT {
  420. break
  421. }
  422. self.scope.allowLet = true
  423. node.Consequent = append(node.Consequent, self.parseStatement())
  424. }
  425. return node
  426. }
  427. func (self *_parser) parseIterationStatement() ast.Statement {
  428. inIteration := self.scope.inIteration
  429. self.scope.inIteration = true
  430. defer func() {
  431. self.scope.inIteration = inIteration
  432. }()
  433. self.scope.allowLet = false
  434. return self.parseStatement()
  435. }
  436. func (self *_parser) parseForIn(idx file.Idx, into ast.ForInto) *ast.ForInStatement {
  437. // Already have consumed "<into> in"
  438. source := self.parseExpression()
  439. self.expect(token.RIGHT_PARENTHESIS)
  440. return &ast.ForInStatement{
  441. For: idx,
  442. Into: into,
  443. Source: source,
  444. Body: self.parseIterationStatement(),
  445. }
  446. }
  447. func (self *_parser) parseForOf(idx file.Idx, into ast.ForInto) *ast.ForOfStatement {
  448. // Already have consumed "<into> of"
  449. source := self.parseAssignmentExpression()
  450. self.expect(token.RIGHT_PARENTHESIS)
  451. return &ast.ForOfStatement{
  452. For: idx,
  453. Into: into,
  454. Source: source,
  455. Body: self.parseIterationStatement(),
  456. }
  457. }
  458. func (self *_parser) parseFor(idx file.Idx, initializer ast.ForLoopInitializer) *ast.ForStatement {
  459. // Already have consumed "<initializer> ;"
  460. var test, update ast.Expression
  461. if self.token != token.SEMICOLON {
  462. test = self.parseExpression()
  463. }
  464. self.expect(token.SEMICOLON)
  465. if self.token != token.RIGHT_PARENTHESIS {
  466. update = self.parseExpression()
  467. }
  468. self.expect(token.RIGHT_PARENTHESIS)
  469. return &ast.ForStatement{
  470. For: idx,
  471. Initializer: initializer,
  472. Test: test,
  473. Update: update,
  474. Body: self.parseIterationStatement(),
  475. }
  476. }
  477. func (self *_parser) parseForOrForInStatement() ast.Statement {
  478. idx := self.expect(token.FOR)
  479. self.expect(token.LEFT_PARENTHESIS)
  480. var initializer ast.ForLoopInitializer
  481. forIn := false
  482. forOf := false
  483. var into ast.ForInto
  484. if self.token != token.SEMICOLON {
  485. allowIn := self.scope.allowIn
  486. self.scope.allowIn = false
  487. tok := self.token
  488. if tok == token.LET {
  489. switch self.peek() {
  490. case token.IDENTIFIER, token.LEFT_BRACKET, token.LEFT_BRACE:
  491. default:
  492. tok = token.IDENTIFIER
  493. }
  494. }
  495. if tok == token.VAR || tok == token.LET || tok == token.CONST {
  496. idx := self.idx
  497. self.next()
  498. var list []*ast.Binding
  499. if tok == token.VAR {
  500. list = self.parseVarDeclarationList(idx)
  501. } else {
  502. list = self.parseVariableDeclarationList()
  503. }
  504. if len(list) == 1 {
  505. if self.token == token.IN {
  506. self.next() // in
  507. forIn = true
  508. } else if self.token == token.IDENTIFIER && self.literal == "of" {
  509. self.next()
  510. forOf = true
  511. }
  512. }
  513. if forIn || forOf {
  514. if list[0].Initializer != nil {
  515. self.error(list[0].Initializer.Idx0(), "for-in loop variable declaration may not have an initializer")
  516. }
  517. if tok == token.VAR {
  518. into = &ast.ForIntoVar{
  519. Binding: list[0],
  520. }
  521. } else {
  522. into = &ast.ForDeclaration{
  523. Idx: idx,
  524. IsConst: tok == token.CONST,
  525. Target: list[0].Target,
  526. }
  527. }
  528. } else {
  529. self.ensurePatternInit(list)
  530. if tok == token.VAR {
  531. initializer = &ast.ForLoopInitializerVarDeclList{
  532. List: list,
  533. }
  534. } else {
  535. initializer = &ast.ForLoopInitializerLexicalDecl{
  536. LexicalDeclaration: ast.LexicalDeclaration{
  537. Idx: idx,
  538. Token: tok,
  539. List: list,
  540. },
  541. }
  542. }
  543. }
  544. } else {
  545. expr := self.parseExpression()
  546. if self.token == token.IN {
  547. self.next()
  548. forIn = true
  549. } else if self.token == token.IDENTIFIER && self.literal == "of" {
  550. self.next()
  551. forOf = true
  552. }
  553. if forIn || forOf {
  554. switch e := expr.(type) {
  555. case *ast.Identifier, *ast.DotExpression, *ast.PrivateDotExpression, *ast.BracketExpression, *ast.Binding:
  556. // These are all acceptable
  557. case *ast.ObjectLiteral:
  558. expr = self.reinterpretAsObjectAssignmentPattern(e)
  559. case *ast.ArrayLiteral:
  560. expr = self.reinterpretAsArrayAssignmentPattern(e)
  561. default:
  562. self.error(idx, "Invalid left-hand side in for-in or for-of")
  563. self.nextStatement()
  564. return &ast.BadStatement{From: idx, To: self.idx}
  565. }
  566. into = &ast.ForIntoExpression{
  567. Expression: expr,
  568. }
  569. } else {
  570. initializer = &ast.ForLoopInitializerExpression{
  571. Expression: expr,
  572. }
  573. }
  574. }
  575. self.scope.allowIn = allowIn
  576. }
  577. if forIn {
  578. return self.parseForIn(idx, into)
  579. }
  580. if forOf {
  581. return self.parseForOf(idx, into)
  582. }
  583. self.expect(token.SEMICOLON)
  584. return self.parseFor(idx, initializer)
  585. }
  586. func (self *_parser) ensurePatternInit(list []*ast.Binding) {
  587. for _, item := range list {
  588. if _, ok := item.Target.(ast.Pattern); ok {
  589. if item.Initializer == nil {
  590. self.error(item.Idx1(), "Missing initializer in destructuring declaration")
  591. break
  592. }
  593. }
  594. }
  595. }
  596. func (self *_parser) parseVariableStatement() *ast.VariableStatement {
  597. idx := self.expect(token.VAR)
  598. list := self.parseVarDeclarationList(idx)
  599. self.ensurePatternInit(list)
  600. self.semicolon()
  601. return &ast.VariableStatement{
  602. Var: idx,
  603. List: list,
  604. }
  605. }
  606. func (self *_parser) parseLexicalDeclaration(tok token.Token) *ast.LexicalDeclaration {
  607. idx := self.expect(tok)
  608. if !self.scope.allowLet {
  609. self.error(idx, "Lexical declaration cannot appear in a single-statement context")
  610. }
  611. list := self.parseVariableDeclarationList()
  612. self.ensurePatternInit(list)
  613. self.semicolon()
  614. return &ast.LexicalDeclaration{
  615. Idx: idx,
  616. Token: tok,
  617. List: list,
  618. }
  619. }
  620. func (self *_parser) parseDoWhileStatement() ast.Statement {
  621. inIteration := self.scope.inIteration
  622. self.scope.inIteration = true
  623. defer func() {
  624. self.scope.inIteration = inIteration
  625. }()
  626. self.expect(token.DO)
  627. node := &ast.DoWhileStatement{}
  628. if self.token == token.LEFT_BRACE {
  629. node.Body = self.parseBlockStatement()
  630. } else {
  631. self.scope.allowLet = false
  632. node.Body = self.parseStatement()
  633. }
  634. self.expect(token.WHILE)
  635. self.expect(token.LEFT_PARENTHESIS)
  636. node.Test = self.parseExpression()
  637. self.expect(token.RIGHT_PARENTHESIS)
  638. if self.token == token.SEMICOLON {
  639. self.next()
  640. }
  641. return node
  642. }
  643. func (self *_parser) parseWhileStatement() ast.Statement {
  644. self.expect(token.WHILE)
  645. self.expect(token.LEFT_PARENTHESIS)
  646. node := &ast.WhileStatement{
  647. Test: self.parseExpression(),
  648. }
  649. self.expect(token.RIGHT_PARENTHESIS)
  650. node.Body = self.parseIterationStatement()
  651. return node
  652. }
  653. func (self *_parser) parseIfStatement() ast.Statement {
  654. self.expect(token.IF)
  655. self.expect(token.LEFT_PARENTHESIS)
  656. node := &ast.IfStatement{
  657. Test: self.parseExpression(),
  658. }
  659. self.expect(token.RIGHT_PARENTHESIS)
  660. if self.token == token.LEFT_BRACE {
  661. node.Consequent = self.parseBlockStatement()
  662. } else {
  663. self.scope.allowLet = false
  664. node.Consequent = self.parseStatement()
  665. }
  666. if self.token == token.ELSE {
  667. self.next()
  668. self.scope.allowLet = false
  669. node.Alternate = self.parseStatement()
  670. }
  671. return node
  672. }
  673. func (self *_parser) parseSourceElements() (body []ast.Statement) {
  674. for self.token != token.EOF {
  675. self.scope.allowLet = true
  676. body = append(body, self.parseStatement())
  677. }
  678. return body
  679. }
  680. func (self *_parser) parseProgram() *ast.Program {
  681. self.openScope()
  682. defer self.closeScope()
  683. prg := &ast.Program{
  684. Body: self.parseSourceElements(),
  685. DeclarationList: self.scope.declarationList,
  686. File: self.file,
  687. }
  688. self.file.SetSourceMap(self.parseSourceMap())
  689. return prg
  690. }
  691. func extractSourceMapLine(str string) string {
  692. for {
  693. p := strings.LastIndexByte(str, '\n')
  694. line := str[p+1:]
  695. if line != "" && line != "})" {
  696. if strings.HasPrefix(line, "//# sourceMappingURL=") {
  697. return line
  698. }
  699. break
  700. }
  701. if p >= 0 {
  702. str = str[:p]
  703. } else {
  704. break
  705. }
  706. }
  707. return ""
  708. }
  709. func (self *_parser) parseSourceMap() *sourcemap.Consumer {
  710. if self.opts.disableSourceMaps {
  711. return nil
  712. }
  713. if smLine := extractSourceMapLine(self.str); smLine != "" {
  714. urlIndex := strings.Index(smLine, "=")
  715. urlStr := smLine[urlIndex+1:]
  716. var data []byte
  717. var err error
  718. if strings.HasPrefix(urlStr, "data:application/json") {
  719. b64Index := strings.Index(urlStr, ",")
  720. b64 := urlStr[b64Index+1:]
  721. data, err = base64.StdEncoding.DecodeString(b64)
  722. } else {
  723. if sourceURL := file.ResolveSourcemapURL(self.file.Name(), urlStr); sourceURL != nil {
  724. if self.opts.sourceMapLoader != nil {
  725. data, err = self.opts.sourceMapLoader(sourceURL.String())
  726. } else {
  727. if sourceURL.Scheme == "" || sourceURL.Scheme == "file" {
  728. data, err = os.ReadFile(sourceURL.Path)
  729. } else {
  730. err = fmt.Errorf("unsupported source map URL scheme: %s", sourceURL.Scheme)
  731. }
  732. }
  733. }
  734. }
  735. if err != nil {
  736. self.error(file.Idx(0), "Could not load source map: %v", err)
  737. return nil
  738. }
  739. if data == nil {
  740. return nil
  741. }
  742. if sm, err := sourcemap.Parse(self.file.Name(), data); err == nil {
  743. return sm
  744. } else {
  745. self.error(file.Idx(0), "Could not parse source map: %v", err)
  746. }
  747. }
  748. return nil
  749. }
  750. func (self *_parser) parseBreakStatement() ast.Statement {
  751. idx := self.expect(token.BREAK)
  752. semicolon := self.implicitSemicolon
  753. if self.token == token.SEMICOLON {
  754. semicolon = true
  755. self.next()
  756. }
  757. if semicolon || self.token == token.RIGHT_BRACE {
  758. self.implicitSemicolon = false
  759. if !self.scope.inIteration && !self.scope.inSwitch {
  760. goto illegal
  761. }
  762. return &ast.BranchStatement{
  763. Idx: idx,
  764. Token: token.BREAK,
  765. }
  766. }
  767. self.tokenToBindingId()
  768. if self.token == token.IDENTIFIER {
  769. identifier := self.parseIdentifier()
  770. if !self.scope.hasLabel(identifier.Name) {
  771. self.error(idx, "Undefined label '%s'", identifier.Name)
  772. return &ast.BadStatement{From: idx, To: identifier.Idx1()}
  773. }
  774. self.semicolon()
  775. return &ast.BranchStatement{
  776. Idx: idx,
  777. Token: token.BREAK,
  778. Label: identifier,
  779. }
  780. }
  781. self.expect(token.IDENTIFIER)
  782. illegal:
  783. self.error(idx, "Illegal break statement")
  784. self.nextStatement()
  785. return &ast.BadStatement{From: idx, To: self.idx}
  786. }
  787. func (self *_parser) parseContinueStatement() ast.Statement {
  788. idx := self.expect(token.CONTINUE)
  789. semicolon := self.implicitSemicolon
  790. if self.token == token.SEMICOLON {
  791. semicolon = true
  792. self.next()
  793. }
  794. if semicolon || self.token == token.RIGHT_BRACE {
  795. self.implicitSemicolon = false
  796. if !self.scope.inIteration {
  797. goto illegal
  798. }
  799. return &ast.BranchStatement{
  800. Idx: idx,
  801. Token: token.CONTINUE,
  802. }
  803. }
  804. self.tokenToBindingId()
  805. if self.token == token.IDENTIFIER {
  806. identifier := self.parseIdentifier()
  807. if !self.scope.hasLabel(identifier.Name) {
  808. self.error(idx, "Undefined label '%s'", identifier.Name)
  809. return &ast.BadStatement{From: idx, To: identifier.Idx1()}
  810. }
  811. if !self.scope.inIteration {
  812. goto illegal
  813. }
  814. self.semicolon()
  815. return &ast.BranchStatement{
  816. Idx: idx,
  817. Token: token.CONTINUE,
  818. Label: identifier,
  819. }
  820. }
  821. self.expect(token.IDENTIFIER)
  822. illegal:
  823. self.error(idx, "Illegal continue statement")
  824. self.nextStatement()
  825. return &ast.BadStatement{From: idx, To: self.idx}
  826. }
  827. // Find the next statement after an error (recover)
  828. func (self *_parser) nextStatement() {
  829. for {
  830. switch self.token {
  831. case token.BREAK, token.CONTINUE,
  832. token.FOR, token.IF, token.RETURN, token.SWITCH,
  833. token.VAR, token.DO, token.TRY, token.WITH,
  834. token.WHILE, token.THROW, token.CATCH, token.FINALLY:
  835. // Return only if parser made some progress since last
  836. // sync or if it has not reached 10 next calls without
  837. // progress. Otherwise consume at least one token to
  838. // avoid an endless parser loop
  839. if self.idx == self.recover.idx && self.recover.count < 10 {
  840. self.recover.count++
  841. return
  842. }
  843. if self.idx > self.recover.idx {
  844. self.recover.idx = self.idx
  845. self.recover.count = 0
  846. return
  847. }
  848. // Reaching here indicates a parser bug, likely an
  849. // incorrect token list in this function, but it only
  850. // leads to skipping of possibly correct code if a
  851. // previous error is present, and thus is preferred
  852. // over a non-terminating parse.
  853. case token.EOF:
  854. return
  855. }
  856. self.next()
  857. }
  858. }