javascript - jsx.go

     1  package javascript
     2  
     3  import "vimagination.zapto.org/parser"
     4  
     5  type jsx struct {
     6  	Tokeniser
     7  }
     8  
     9  func (j *jsx) hasFlags() (bool, bool) {
    10  	t, _ := tokeniserFlags(j.Tokeniser)
    11  
    12  	return t, true
    13  }
    14  
    15  // AsJSX converts the tokeniser to one that handles the JSX extentions to
    16  // JavaScript.
    17  //
    18  // Can be combined with AsTSX to read TSX.
    19  func AsJSX(t Tokeniser) Tokeniser {
    20  	ts, _ := tokeniserFlags(t)
    21  	jsx := &jsx{Tokeniser: t}
    22  
    23  	jsx.TokeniserState((&jsTokeniser{isTypescript: ts, isJSX: true}).inputElement)
    24  
    25  	return jsx
    26  }
    27  
    28  // JSXElement as defined in:
    29  // https://facebook.github.io/jsx/#prod-JSXElement
    30  type JSXElement struct {
    31  	ElementName JSXElementName
    32  	Attributes  []JSXAttribute
    33  	SelfClosing bool
    34  	Children    []JSXChild
    35  	Tokens      Tokens
    36  }
    37  
    38  func (je *JSXElement) parse(j *jsParser) error {
    39  	j.Skip()
    40  
    41  	g := j.NewGoal()
    42  
    43  	if err := je.ElementName.parse(&g); err != nil {
    44  		return j.Error("JSXElement", err)
    45  	}
    46  
    47  	j.Score(g)
    48  
    49  	for {
    50  		j.AcceptRunWhitespace()
    51  
    52  		if j.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "/"}) {
    53  			je.SelfClosing = true
    54  
    55  			if !j.AcceptToken(parser.Token{Type: TokenJSXElementEnd, Data: ">"}) {
    56  				return j.Error("JSXElement", ErrMissingTagClose)
    57  			}
    58  
    59  			break
    60  		} else if j.Accept(TokenJSXElementEnd) {
    61  			j.AcceptRunWhitespace()
    62  
    63  			break
    64  		}
    65  
    66  		g = j.NewGoal()
    67  
    68  		var a JSXAttribute
    69  
    70  		if err := a.parse(&g); err != nil {
    71  			return j.Error("JSXElement", err)
    72  		}
    73  
    74  		j.Score(g)
    75  
    76  		je.Attributes = append(je.Attributes, a)
    77  	}
    78  
    79  	if !je.SelfClosing {
    80  		for {
    81  			g = j.NewGoal()
    82  
    83  			if g.Accept(TokenJSXElementStart) && g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "/"}) {
    84  				j.Score(g)
    85  
    86  				break
    87  			}
    88  
    89  			g = j.NewGoal()
    90  
    91  			var child JSXChild
    92  
    93  			if err := child.parse(&g); err != nil {
    94  				return j.Error("JSXElement", err)
    95  			}
    96  
    97  			je.Children = append(je.Children, child)
    98  
    99  			j.Score(g)
   100  			j.AcceptRunWhitespace()
   101  		}
   102  
   103  		j.AcceptRunWhitespace()
   104  
   105  		g = j.NewGoal()
   106  
   107  		var closing JSXElementName
   108  
   109  		if err := closing.parse(&g); err != nil {
   110  			return j.Error("JSXElement", err)
   111  		}
   112  
   113  		j.Score(g)
   114  
   115  		if !je.ElementName.equal(&closing) {
   116  			return j.Error("JSXElement", ErrInvalidClosingTag)
   117  		}
   118  
   119  		j.AcceptRunWhitespace()
   120  
   121  		if !j.AcceptToken(parser.Token{Type: TokenJSXElementEnd, Data: ">"}) {
   122  			return j.Error("JSXElement", ErrMissingTagClose)
   123  		}
   124  	}
   125  
   126  	je.Tokens = j.ToTokens()
   127  
   128  	return nil
   129  }
   130  
   131  // JSXElementName as defined in:
   132  // https://facebook.github.io/jsx/#prod-JSXElementName
   133  //
   134  // Identifier must be defined, and only one of Namespace and MemberExpression
   135  // can be non-nil.
   136  type JSXElementName struct {
   137  	Namespace        *Token
   138  	Identifier       *Token
   139  	MemberExpression []*Token
   140  	Tokens           Tokens
   141  }
   142  
   143  func (jn *JSXElementName) parse(j *jsParser) error {
   144  	if !j.Accept(TokenJSXIdentifier) {
   145  		return j.Error("JSXElementName", ErrMissingIdentifier)
   146  	}
   147  
   148  	jn.Identifier = j.GetLastToken()
   149  
   150  	if j.AcceptToken(parser.Token{Type: TokenPunctuator, Data: ":"}) {
   151  		if !j.Accept(TokenJSXIdentifier) {
   152  			return j.Error("JSXElementName", ErrMissingIdentifier)
   153  		}
   154  
   155  		jn.Namespace = jn.Identifier
   156  		jn.Identifier = j.GetLastToken()
   157  	} else {
   158  		for j.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "."}) {
   159  			if !j.Accept(TokenJSXIdentifier) {
   160  				return j.Error("JSXElementName", ErrMissingIdentifier)
   161  			}
   162  
   163  			jn.MemberExpression = append(jn.MemberExpression, j.GetLastToken())
   164  		}
   165  	}
   166  
   167  	jn.Tokens = j.ToTokens()
   168  
   169  	return nil
   170  }
   171  
   172  func (jn *JSXElementName) equal(cn *JSXElementName) bool {
   173  	if !jn.Identifier.equal(cn.Identifier) || !jn.Namespace.equal(cn.Namespace) || len(jn.MemberExpression) != len(cn.MemberExpression) {
   174  		return false
   175  	}
   176  
   177  	for n := range jn.MemberExpression {
   178  		if !jn.MemberExpression[n].equal(cn.MemberExpression[n]) {
   179  			return false
   180  		}
   181  	}
   182  
   183  	return true
   184  }
   185  
   186  func (t *Token) equal(s *Token) bool {
   187  	if t == nil {
   188  		return s == nil
   189  	} else if s == nil {
   190  		return false
   191  	}
   192  
   193  	return t.Data == s.Data
   194  }
   195  
   196  // JSXAttribute as defined in:
   197  // https://facebook.github.io/jsx/#prod-JSXAttributes
   198  //
   199  // Namespace can only be non-nil if Identifier is non-nil.
   200  //
   201  // One, and only one of JSXString, JSXFragment, JSXElement, and
   202  // AssignmentExpression must be non-nil.
   203  type JSXAttribute struct {
   204  	Namespace            *Token
   205  	Identifier           *Token
   206  	JSXString            *Token
   207  	JSXFragment          *JSXFragment
   208  	JSXElement           *JSXElement
   209  	AssignmentExpression *AssignmentExpression
   210  	Comments             [3]Comments
   211  	Tokens               Tokens
   212  }
   213  
   214  func (ja *JSXAttribute) parse(j *jsParser) error {
   215  	if j.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "{"}) {
   216  		ja.Comments[0] = j.AcceptRunWhitespaceNoNewlineComments()
   217  		ja.Comments[1] = j.AcceptRunWhitespaceComments()
   218  
   219  		j.AcceptRunWhitespace()
   220  
   221  		if !j.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "..."}) {
   222  			return j.Error("JSXAttribute", ErrMissingSpread)
   223  		}
   224  
   225  		j.AcceptRunWhitespaceNoComment()
   226  
   227  		g := j.NewGoal()
   228  		ja.AssignmentExpression = new(AssignmentExpression)
   229  
   230  		if err := ja.AssignmentExpression.parse(&g, false, false, false); err != nil {
   231  			return j.Error("JSXAttribute", err)
   232  		}
   233  
   234  		j.Score(g)
   235  
   236  		ja.Comments[2] = j.AcceptRunWhitespaceComments()
   237  
   238  		j.AcceptRunWhitespace()
   239  
   240  		if !j.Accept(TokenRightBracePunctuator) {
   241  			return j.Error("JSXAttribute", ErrMissingClosingBrace)
   242  		}
   243  	} else {
   244  		if !j.Accept(TokenJSXIdentifier) {
   245  			return j.Error("JSXAttribute", ErrMissingIdentifier)
   246  		}
   247  
   248  		ja.Identifier = j.GetLastToken()
   249  
   250  		if j.AcceptToken(parser.Token{Type: TokenPunctuator, Data: ":"}) {
   251  			if !j.Accept(TokenJSXIdentifier) {
   252  				return j.Error("JSXAttribute", ErrMissingIdentifier)
   253  			}
   254  
   255  			ja.Namespace = ja.Identifier
   256  			ja.Identifier = j.GetLastToken()
   257  		}
   258  
   259  		if j.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "="}) {
   260  			if j.Accept(TokenJSXString) {
   261  				ja.JSXString = j.GetLastToken()
   262  			} else if j.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "{"}) {
   263  				ja.Comments[0] = j.AcceptRunWhitespaceNoNewlineComments()
   264  
   265  				j.AcceptRunWhitespaceNoComment()
   266  
   267  				g := j.NewGoal()
   268  				ja.AssignmentExpression = new(AssignmentExpression)
   269  
   270  				if err := ja.AssignmentExpression.parse(&g, false, false, false); err != nil {
   271  					return j.Error("JSXAttribute", err)
   272  				}
   273  
   274  				j.Score(g)
   275  
   276  				ja.Comments[2] = j.AcceptRunWhitespaceComments()
   277  
   278  				j.AcceptRunWhitespace()
   279  
   280  				if !j.Accept(TokenRightBracePunctuator) {
   281  					return j.Error("JSXAttribute", ErrMissingClosingBrace)
   282  				}
   283  			} else if tk := j.Peek(); tk.Type == TokenJSXElementStart {
   284  				g := j.NewGoal()
   285  
   286  				g.Skip()
   287  
   288  				if g.AcceptRunWhitespace() == TokenJSXElementEnd {
   289  					g = j.NewGoal()
   290  					ja.JSXFragment = new(JSXFragment)
   291  
   292  					if err := ja.JSXFragment.parse(&g); err != nil {
   293  						return j.Error("JSXAttribute", err)
   294  					}
   295  
   296  					j.Score(g)
   297  				} else {
   298  					g = j.NewGoal()
   299  					ja.JSXElement = new(JSXElement)
   300  
   301  					if err := ja.JSXElement.parse(&g); err != nil {
   302  						return j.Error("JSXAttribute", err)
   303  					}
   304  
   305  					j.Score(g)
   306  				}
   307  			} else {
   308  				return j.Error("JSXAttribute", ErrMissingAttribute)
   309  			}
   310  		} else if tk := j.Peek(); tk.Type != TokenWhitespace && tk.Type != TokenLineTerminator && tk.Type != TokenJSXElementEnd && tk != (parser.Token{Type: TokenPunctuator, Data: "/"}) {
   311  			return j.Error("JSXAttribute", ErrMissingEquals)
   312  		}
   313  	}
   314  
   315  	ja.Tokens = j.ToTokens()
   316  
   317  	return nil
   318  }
   319  
   320  // JSXChild as defined in:
   321  // https://facebook.github.io/jsx/#prod-JSXChild
   322  //
   323  // One, and only one of JSXText, JSXElement, JSXFragment, and JSXChildExpression
   324  // must be non-nil.
   325  //
   326  // Spread can only be true if JSXChildExpression is non-nil.
   327  type JSXChild struct {
   328  	JSXText            *Token
   329  	JSXElement         *JSXElement
   330  	JSXFragment        *JSXFragment
   331  	Spread             bool
   332  	JSXChildExpression *AssignmentExpression
   333  	Comments           [3]Comments
   334  	Tokens             Tokens
   335  }
   336  
   337  func (jc *JSXChild) parse(j *jsParser) error {
   338  	if j.Accept(TokenJSXText) {
   339  		jc.JSXText = j.GetLastToken()
   340  	} else if j.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "{"}) {
   341  		jc.Comments[0] = j.AcceptRunWhitespaceNoNewlineComments()
   342  
   343  		g := j.NewGoal()
   344  
   345  		g.AcceptRunWhitespace()
   346  
   347  		if !g.Accept(TokenRightBracePunctuator) {
   348  			if jc.Spread = g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "..."}); jc.Spread {
   349  				jc.Comments[1] = j.AcceptRunWhitespaceComments()
   350  
   351  				j.AcceptRunWhitespace()
   352  				j.Skip()
   353  			}
   354  
   355  			j.AcceptRunWhitespaceNoComment()
   356  
   357  			g = j.NewGoal()
   358  			jc.JSXChildExpression = new(AssignmentExpression)
   359  
   360  			if err := jc.JSXChildExpression.parse(&g, false, false, false); err != nil {
   361  				return j.Error("JSXChild", err)
   362  			}
   363  
   364  			j.Score(g)
   365  		}
   366  
   367  		jc.Comments[2] = j.AcceptRunWhitespaceComments()
   368  
   369  		j.AcceptRunWhitespace()
   370  
   371  		if !j.Accept(TokenRightBracePunctuator) {
   372  			return j.Error("JSXChild", ErrMissingClosingBrace)
   373  		}
   374  	} else {
   375  		g := j.NewGoal()
   376  
   377  		g.Skip()
   378  
   379  		if g.AcceptRunWhitespace() == TokenJSXElementEnd {
   380  			g = j.NewGoal()
   381  			jc.JSXFragment = new(JSXFragment)
   382  
   383  			if err := jc.JSXFragment.parse(&g); err != nil {
   384  				return j.Error("JSXChild", err)
   385  			}
   386  
   387  			j.Score(g)
   388  		} else {
   389  			g = j.NewGoal()
   390  			jc.JSXElement = new(JSXElement)
   391  
   392  			if err := jc.JSXElement.parse(&g); err != nil {
   393  				return j.Error("JSXChild", err)
   394  			}
   395  
   396  			j.Score(g)
   397  		}
   398  	}
   399  
   400  	jc.Tokens = j.ToTokens()
   401  
   402  	return nil
   403  }
   404  
   405  // JSXFragment as defined in:
   406  // https://facebook.github.io/jsx/#prod-JSXFragment
   407  type JSXFragment struct {
   408  	Children []JSXChild
   409  	Tokens   Tokens
   410  }
   411  
   412  func (jf *JSXFragment) parse(j *jsParser) error {
   413  	j.Skip()
   414  	j.AcceptRunWhitespace()
   415  	j.Skip()
   416  
   417  	for {
   418  		j.AcceptRunWhitespace()
   419  
   420  		g := j.NewGoal()
   421  
   422  		if g.Accept(TokenJSXElementStart) && g.AcceptToken(parser.Token{Type: TokenPunctuator, Data: "/"}) {
   423  			break
   424  		}
   425  
   426  		g = j.NewGoal()
   427  
   428  		var child JSXChild
   429  
   430  		if err := child.parse(&g); err != nil {
   431  			return j.Error("JSXFragment", err)
   432  		}
   433  
   434  		jf.Children = append(jf.Children, child)
   435  
   436  		j.Score(g)
   437  		j.AcceptRunWhitespace()
   438  	}
   439  
   440  	j.Skip()
   441  	j.Skip()
   442  	j.AcceptRunWhitespace()
   443  
   444  	if !j.Accept(TokenJSXElementEnd) {
   445  		return j.Error("JSXFragment", ErrMissingTagClose)
   446  	}
   447  
   448  	jf.Tokens = j.ToTokens()
   449  
   450  	return nil
   451  }
   452