javascript - process.go

     1  package scope
     2  
     3  import (
     4  	"vimagination.zapto.org/javascript"
     5  	"vimagination.zapto.org/javascript/walk"
     6  )
     7  
     8  type scoper struct {
     9  	bt    BindingType
    10  	scope *Scope
    11  	set   bool
    12  }
    13  
    14  func (s *scoper) newFunctionScope(t javascript.Type) *scoper {
    15  	return s.newScoper(s.scope.newFunctionScope(t), BindingRef)
    16  }
    17  
    18  func (s *scoper) newScoper(t *Scope, bt BindingType) *scoper {
    19  	return &scoper{
    20  		bt:    bt,
    21  		scope: t,
    22  		set:   s.set,
    23  	}
    24  }
    25  
    26  func (s *scoper) newArrowFunctionScope(t javascript.Type) *scoper {
    27  	return s.newScoper(s.scope.newArrowFunctionScope(t), s.bt)
    28  }
    29  
    30  func (s *scoper) newLexicalScope(t javascript.Type) *scoper {
    31  	return s.newScoper(s.scope.newLexicalScope(t), s.bt)
    32  }
    33  
    34  func (s *scoper) setBindingType(bt BindingType) *scoper {
    35  	return s.newScoper(s.scope, bt)
    36  }
    37  
    38  func (s *scoper) Handle(t javascript.Type) error {
    39  	switch t := t.(type) {
    40  	case *javascript.ImportDeclaration:
    41  		return s.processImportDeclaration(t)
    42  	case *javascript.ExportDeclaration:
    43  		return s.processExportDeclaration(t)
    44  	case *javascript.ExportSpecifier:
    45  		return s.processExportSpecifier(t)
    46  	case *javascript.Statement:
    47  		return s.processStatement(t)
    48  	case *javascript.Declaration:
    49  		return s.processDeclaration(t)
    50  	case *javascript.IterationStatementFor:
    51  		return s.processIterationStatementFor(t)
    52  	case *javascript.SwitchStatement:
    53  		return s.processSwitchStatement(t)
    54  	case *javascript.FunctionDeclaration:
    55  		return s.processFunctionDeclaration(t)
    56  	case *javascript.TryStatement:
    57  		return s.processTryStatement(t)
    58  	case *javascript.ClassDeclaration:
    59  		return s.processClassDeclaration(t)
    60  	case *javascript.ClassElement:
    61  		return s.processClassElement(t)
    62  	case *javascript.LexicalDeclaration:
    63  		return s.processLexicalDeclaration(t)
    64  	case *javascript.VariableStatement:
    65  		return s.processVariableStatment(t)
    66  	case *javascript.LexicalBinding:
    67  		return s.processLexicalBinding(t)
    68  	case *javascript.AssignmentExpression:
    69  		return s.processAssignmentExpression(t)
    70  	case *javascript.ObjectAssignmentPattern:
    71  		return s.processObjectAssignmentPattern(t)
    72  	case *javascript.DestructuringAssignmentTarget:
    73  		return s.processDestructuringAssignmentTarget(t)
    74  	case *javascript.ObjectBindingPattern:
    75  		return s.processObjectBindingPattern(t)
    76  	case *javascript.FormalParameters:
    77  		return s.processFormalParameters(t)
    78  	case *javascript.MethodDefinition:
    79  		return s.processMethodDefinition(t)
    80  	case *javascript.ArrowFunction:
    81  		return s.processArrowFunction(t)
    82  	case *javascript.BindingElement:
    83  		return s.processBindingElement(t)
    84  	case *javascript.PrimaryExpression:
    85  		return s.processPrimaryExpression(t)
    86  	case *javascript.JSXElement:
    87  		return s.processJSXElement(t)
    88  	}
    89  
    90  	return walk.Walk(t, s)
    91  }
    92  
    93  func (s *scoper) processImportDeclaration(t *javascript.ImportDeclaration) error {
    94  	if !s.set || t.ImportClause == nil {
    95  		return nil
    96  	}
    97  
    98  	if t.ImportedDefaultBinding != nil {
    99  		if err := s.scope.setBinding(t.ImportedDefaultBinding, BindingImport); err != nil {
   100  			return err
   101  		}
   102  	}
   103  
   104  	if t.NameSpaceImport != nil {
   105  		if err := s.scope.setBinding(t.NameSpaceImport, BindingImport); err != nil {
   106  			return err
   107  		}
   108  	}
   109  
   110  	if t.NamedImports != nil {
   111  		for _, is := range t.NamedImports.ImportList {
   112  			if is.ImportedBinding != nil {
   113  				if err := s.scope.setBinding(is.ImportedBinding, BindingImport); err != nil {
   114  					return err
   115  				}
   116  			}
   117  		}
   118  	}
   119  
   120  	return nil
   121  }
   122  
   123  func (s *scoper) processExportDeclaration(t *javascript.ExportDeclaration) error {
   124  	if t.DefaultFunction != nil || t.DefaultClass != nil {
   125  		return walk.Walk(t, s.setBindingType(BindingHoistable))
   126  	}
   127  
   128  	return walk.Walk(t, s)
   129  }
   130  
   131  func (s *scoper) processExportSpecifier(t *javascript.ExportSpecifier) error {
   132  	if !s.set && t.IdentifierName != nil {
   133  		s.scope.addBinding(t.IdentifierName, BindingRef)
   134  	}
   135  
   136  	return nil
   137  }
   138  
   139  func (s *scoper) processStatement(t *javascript.Statement) error {
   140  	if t.BlockStatement != nil {
   141  		s = s.newLexicalScope(t.BlockStatement)
   142  	} else if t.LabelledItemFunction != nil {
   143  		s = s.setBindingType(BindingHoistable)
   144  	}
   145  
   146  	return walk.Walk(t, s)
   147  }
   148  
   149  func (s *scoper) processDeclaration(t *javascript.Declaration) error {
   150  	if t.FunctionDeclaration != nil || t.ClassDeclaration != nil {
   151  		s = s.setBindingType(BindingHoistable)
   152  	}
   153  
   154  	return walk.Walk(t, s)
   155  }
   156  
   157  func (s *scoper) processIterationStatementFor(t *javascript.IterationStatementFor) error {
   158  	s = s.newLexicalScope(t)
   159  
   160  	switch t.Type {
   161  	case javascript.ForInLet, javascript.ForOfLet, javascript.ForAwaitOfLet:
   162  		s = s.setBindingType(BindingLexicalLet)
   163  	case javascript.ForInConst, javascript.ForOfConst, javascript.ForAwaitOfConst:
   164  		s = s.setBindingType(BindingLexicalConst)
   165  	case javascript.ForNormalVar, javascript.ForInVar, javascript.ForOfVar, javascript.ForAwaitOfVar:
   166  		s = s.setBindingType(BindingVar)
   167  	}
   168  
   169  	if s.set && t.ForBindingIdentifier != nil {
   170  		if err := s.scope.setBinding(t.ForBindingIdentifier, s.bt); err != nil {
   171  			return err
   172  		}
   173  	}
   174  
   175  	return walk.Walk(t, s)
   176  }
   177  
   178  func (s *scoper) processSwitchStatement(t *javascript.SwitchStatement) error {
   179  	if err := walk.Walk(&t.Expression, s); err != nil {
   180  		return err
   181  	}
   182  
   183  	s = s.newLexicalScope(t)
   184  
   185  	for n := range t.CaseClauses {
   186  		if err := walk.Walk(&t.CaseClauses[n], s); err != nil {
   187  			return err
   188  		}
   189  	}
   190  
   191  	for n := range t.DefaultClause {
   192  		if err := walk.Walk(&t.DefaultClause[n], s); err != nil {
   193  			return err
   194  		}
   195  	}
   196  
   197  	for n := range t.PostDefaultCaseClauses {
   198  		if err := walk.Walk(&t.PostDefaultCaseClauses[n], s); err != nil {
   199  			return err
   200  		}
   201  	}
   202  
   203  	return nil
   204  }
   205  
   206  func (s *scoper) processFunctionDeclaration(t *javascript.FunctionDeclaration) error {
   207  	if s.bt == BindingHoistable && s.set && t.BindingIdentifier != nil {
   208  		if err := s.scope.setBinding(t.BindingIdentifier, BindingHoistable); err != nil {
   209  			return err
   210  		}
   211  	}
   212  
   213  	return walk.Walk(t, s.newFunctionScope(t))
   214  }
   215  
   216  func (s *scoper) processTryStatement(t *javascript.TryStatement) error {
   217  	if err := walk.Walk(&t.TryBlock, s.newLexicalScope(&t.TryBlock)); err != nil {
   218  		return err
   219  	}
   220  
   221  	if t.CatchBlock != nil {
   222  		s = s.newLexicalScope(t.CatchBlock)
   223  
   224  		if t.CatchParameterArrayBindingPattern != nil {
   225  			if err := walk.Walk(t.CatchParameterArrayBindingPattern, s.setBindingType(BindingCatch)); err != nil {
   226  				return err
   227  			}
   228  		} else if t.CatchParameterObjectBindingPattern != nil {
   229  			if err := walk.Walk(t.CatchParameterObjectBindingPattern, s.setBindingType(BindingCatch)); err != nil {
   230  				return err
   231  			}
   232  		} else if s.set && t.CatchParameterBindingIdentifier != nil {
   233  			s.scope.setBinding(t.CatchParameterBindingIdentifier, BindingCatch)
   234  		}
   235  
   236  		if err := walk.Walk(t.CatchBlock, s); err != nil {
   237  			return err
   238  		}
   239  	}
   240  
   241  	if t.FinallyBlock != nil {
   242  		return walk.Walk(t.FinallyBlock, s.newLexicalScope(t.FinallyBlock))
   243  	}
   244  
   245  	return nil
   246  }
   247  
   248  func (s *scoper) processClassDeclaration(t *javascript.ClassDeclaration) error {
   249  	if s.bt == BindingHoistable && s.set && t.BindingIdentifier != nil {
   250  		if err := s.scope.setBinding(t.BindingIdentifier, BindingHoistable); err != nil {
   251  			return err
   252  		}
   253  	}
   254  
   255  	return walk.Walk(t, s.setBindingType(BindingRef))
   256  }
   257  
   258  func (s *scoper) processClassElement(t *javascript.ClassElement) error {
   259  	if t.ClassStaticBlock != nil {
   260  		s = s.newLexicalScope(t.ClassStaticBlock)
   261  	}
   262  
   263  	return walk.Walk(t, s)
   264  }
   265  
   266  func (s *scoper) processLexicalDeclaration(t *javascript.LexicalDeclaration) error {
   267  	typ := BindingLexicalLet
   268  
   269  	if t.LetOrConst == javascript.Const {
   270  		typ = BindingLexicalConst
   271  	}
   272  
   273  	return walk.Walk(t, s.setBindingType(typ))
   274  }
   275  
   276  func (s *scoper) processVariableStatment(t *javascript.VariableStatement) error {
   277  	return walk.Walk(t, s.setBindingType(BindingVar))
   278  }
   279  
   280  func (s *scoper) processLexicalBinding(t *javascript.LexicalBinding) error {
   281  	if s.set && t.BindingIdentifier != nil {
   282  		if err := s.scope.setBinding(t.BindingIdentifier, s.bt); err != nil {
   283  			return err
   284  		}
   285  	}
   286  
   287  	return walk.Walk(t, s)
   288  }
   289  
   290  func (s *scoper) processAssignmentExpression(t *javascript.AssignmentExpression) error {
   291  	if t.LeftHandSideExpression != nil {
   292  		if err := s.processLeftHandSideExpressionAsAssignment(t.LeftHandSideExpression); err != nil {
   293  			return err
   294  		} else if t.AssignmentExpression == nil {
   295  			return nil
   296  		}
   297  
   298  		return walk.Walk(t.AssignmentExpression, s)
   299  	}
   300  
   301  	return walk.Walk(t, s)
   302  }
   303  
   304  func (s *scoper) processLeftHandSideExpressionAsAssignment(t *javascript.LeftHandSideExpression) error {
   305  	if t.NewExpression != nil && len(t.NewExpression.News) == 0 && t.NewExpression.MemberExpression.PrimaryExpression != nil && t.NewExpression.MemberExpression.PrimaryExpression.IdentifierReference != nil {
   306  		if !s.set {
   307  			s.scope.addBinding(t.NewExpression.MemberExpression.PrimaryExpression.IdentifierReference, BindingBare)
   308  		}
   309  
   310  		return nil
   311  	}
   312  
   313  	return walk.Walk(t, s)
   314  }
   315  
   316  func (s *scoper) processObjectAssignmentPattern(t *javascript.ObjectAssignmentPattern) error {
   317  	for n := range t.AssignmentPropertyList {
   318  		if err := walk.Walk(&t.AssignmentPropertyList[n], s); err != nil {
   319  			return err
   320  		}
   321  	}
   322  
   323  	if t.AssignmentRestElement != nil {
   324  		return s.processLeftHandSideExpressionAsAssignment(t.AssignmentRestElement)
   325  	}
   326  
   327  	return nil
   328  }
   329  
   330  func (s *scoper) processDestructuringAssignmentTarget(t *javascript.DestructuringAssignmentTarget) error {
   331  	if t.LeftHandSideExpression != nil {
   332  		return s.processLeftHandSideExpressionAsAssignment(t.LeftHandSideExpression)
   333  	} else if t.AssignmentPattern != nil {
   334  		return walk.Walk(t.AssignmentPattern, s)
   335  	}
   336  
   337  	return nil
   338  }
   339  
   340  func (s *scoper) processObjectBindingPattern(t *javascript.ObjectBindingPattern) error {
   341  	if err := walk.Walk(t, s); err != nil {
   342  		return err
   343  	} else if s.set && t.BindingRestProperty != nil {
   344  		return s.scope.setBinding(t.BindingRestProperty, s.bt)
   345  	}
   346  
   347  	return nil
   348  }
   349  
   350  func (s *scoper) processFormalParameters(t *javascript.FormalParameters) error {
   351  	if err := walk.Walk(t, s.setBindingType(BindingFunctionParam)); err != nil {
   352  		return err
   353  	} else if s.set && t.BindingIdentifier != nil {
   354  		return s.scope.setBinding(t.BindingIdentifier, BindingFunctionParam)
   355  	}
   356  
   357  	return nil
   358  }
   359  
   360  func (s *scoper) processMethodDefinition(t *javascript.MethodDefinition) error {
   361  	if err := walk.Walk(t.ClassElementName, s); err != nil {
   362  		return err
   363  	}
   364  
   365  	s = s.newFunctionScope(t)
   366  
   367  	if err := walk.Walk(&t.Params, s); err != nil {
   368  		return err
   369  	}
   370  
   371  	return walk.Walk(&t.FunctionBody, s)
   372  }
   373  
   374  func (s *scoper) processArrowFunction(t *javascript.ArrowFunction) error {
   375  	s = s.newArrowFunctionScope(t)
   376  
   377  	if s.set && t.BindingIdentifier != nil {
   378  		s.scope.setBinding(t.BindingIdentifier, BindingFunctionParam)
   379  	}
   380  
   381  	return walk.Walk(t, s)
   382  }
   383  
   384  func (s *scoper) processBindingElement(t *javascript.BindingElement) error {
   385  	if s.set && t.SingleNameBinding != nil {
   386  		if err := s.scope.setBinding(t.SingleNameBinding, s.bt); err != nil {
   387  			return err
   388  		}
   389  	}
   390  
   391  	return walk.Walk(t, s)
   392  }
   393  
   394  func (s *scoper) processPrimaryExpression(t *javascript.PrimaryExpression) error {
   395  	if t.This != nil {
   396  		if !s.set {
   397  			s.scope.addBinding(t.This, BindingRef)
   398  		}
   399  	} else if t.IdentifierReference != nil {
   400  		if !s.set {
   401  			s.scope.addBinding(t.IdentifierReference, BindingRef)
   402  		}
   403  	} else {
   404  		return walk.Walk(t, s)
   405  	}
   406  
   407  	return nil
   408  }
   409  
   410  func (s *scoper) processJSXElement(t *javascript.JSXElement) error {
   411  	if !s.set && t.ElementName.Identifier != nil {
   412  		s.scope.addBinding(t.ElementName.Identifier, BindingRef)
   413  	}
   414  
   415  	return walk.Walk(t, s)
   416  }
   417