rename Node to SyntaxNode to avoid confusion

nedpals · nedpals · commit c519775725e8 · 2023-09-09T10:49:14.000+08:00
diff --git a/context.go b/context.go
@@ -3,7 +3,7 @@ package errgoengine
 type MainError struct {
 	ErrorNode *StackTraceEntry
 	Document  *Document
-	Nearest   Node
+	Nearest   SyntaxNode
 }
 
 func (err MainError) DocumentPath() string {
@@ -40,7 +40,7 @@ func (data *ContextData) FindSymbol(name string, pos int) Symbol {
 	return data.Store.FindSymbol(path, name, pos)
 }
 
-func (data *ContextData) AnalyzeValue(n Node) Symbol {
+func (data *ContextData) AnalyzeValue(n SyntaxNode) Symbol {
 	return n.Doc.Language.ValueAnalyzer(data, n)
 }
 
diff --git a/imports.go b/imports.go
@@ -1,7 +1,7 @@
 package errgoengine
 
 type ImportParams struct {
-	Node       Node
+	Node       SyntaxNode
 	CurrentDir string
 }
 
diff --git a/language.go b/language.go
@@ -18,7 +18,7 @@ type Language struct {
 	ErrorPattern      string
 	SymbolsToCapture  ISymbolCaptureList
 	LocationConverter func(path, pos string) Location
-	ValueAnalyzer     func(NodeValueAnalyzer, Node) Symbol
+	ValueAnalyzer     func(NodeValueAnalyzer, SyntaxNode) Symbol
 	ImportResolver    func(NodeValueAnalyzer, ImportParams) ResolvedImport
 }
 
diff --git a/languages/java/language.go b/languages/java/language.go
@@ -12,7 +12,7 @@ var Language = &lib.Language{
 	FilePatterns:      []string{".java"},
 	SitterLanguage:    java.GetLanguage(),
 	StackTracePattern: `\s+at (?P<symbol>\S+)\((?P<path>\S+):(?P<position>\d+)\)`,
-	ValueAnalyzer: func(an lib.NodeValueAnalyzer, n lib.Node) lib.Symbol {
+	ValueAnalyzer: func(an lib.NodeValueAnalyzer, n lib.SyntaxNode) lib.Symbol {
 		switch n.Type() {
 		// types first
 		case "array_type":
diff --git a/languages/python/language.go b/languages/python/language.go
@@ -11,7 +11,7 @@ var Language = &lib.Language{
 	SitterLanguage:    python.GetLanguage(),
 	StackTracePattern: `\s+File "(?P<path>\S+)", line (?P<position>\d+), in (?P<symbol>\S+)`,
 	ErrorPattern:      `Traceback \(most recent call last\):$stacktrace$message`,
-	ValueAnalyzer: func(nva lib.NodeValueAnalyzer, n lib.Node) lib.Symbol {
+	ValueAnalyzer: func(nva lib.NodeValueAnalyzer, n lib.SyntaxNode) lib.Symbol {
 		// TODO:
 		return lib.Builtin("void")
 	},
diff --git a/node.go b/node.go
@@ -4,41 +4,41 @@ import (
 	sitter "github.com/smacker/go-tree-sitter"
 )
 
-type Node struct {
+type SyntaxNode struct {
 	*sitter.Node
 	Doc  *Document
 	text string
 }
 
-func (n Node) Text() string {
+func (n SyntaxNode) Text() string {
 	return n.text
 }
 
-func (n Node) ChildByFieldName(field string) Node {
+func (n SyntaxNode) ChildByFieldName(field string) SyntaxNode {
 	cNode := n.Node.ChildByFieldName(field)
 	return WrapNode(n.Doc, cNode)
 }
 
-func (n Node) Parent() Node {
+func (n SyntaxNode) Parent() SyntaxNode {
 	return WrapNode(n.Doc, n.Node.Parent())
 }
 
-func (n Node) NamedChild(idx int) Node {
+func (n SyntaxNode) NamedChild(idx int) SyntaxNode {
 	cNode := n.Node.NamedChild(idx)
 	return WrapNode(n.Doc, cNode)
 }
 
-func (n Node) LastNamedChild() Node {
+func (n SyntaxNode) LastNamedChild() SyntaxNode {
 	len := n.Node.NamedChildCount()
 	return n.NamedChild(int(len) - 1)
 }
 
-func (n Node) Child(idx int) Node {
+func (n SyntaxNode) Child(idx int) SyntaxNode {
 	cNode := n.Node.Child(idx)
 	return WrapNode(n.Doc, cNode)
 }
 
-func (n Node) StartPosition() Position {
+func (n SyntaxNode) StartPosition() Position {
 	p := n.Node.StartPoint()
 	return Position{
 		Line:   int(p.Row),
@@ -47,7 +47,7 @@ func (n Node) StartPosition() Position {
 	}
 }
 
-func (n Node) EndPosition() Position {
+func (n SyntaxNode) EndPosition() Position {
 	p := n.Node.EndPoint()
 	return Position{
 		Line:   int(p.Row),
@@ -56,19 +56,19 @@ func (n Node) EndPosition() Position {
 	}
 }
 
-func (n Node) Location() Location {
+func (n SyntaxNode) Location() Location {
 	return Location{
 		DocumentPath: n.Doc.Path,
 		Position:     n.StartPosition(),
 	}
 }
 
-func (n Node) RawNode() *sitter.Node {
+func (n SyntaxNode) RawNode() *sitter.Node {
 	return n.Node
 }
 
-func WrapNode(doc *Document, n *sitter.Node) Node {
-	return Node{
+func WrapNode(doc *Document, n *sitter.Node) SyntaxNode {
+	return SyntaxNode{
 		text: n.Content([]byte(doc.Contents)),
 		Doc:  doc,
 		Node: n,
@@ -77,7 +77,7 @@ func WrapNode(doc *Document, n *sitter.Node) Node {
 
 type NodeValueAnalyzer interface {
 	FindSymbol(name string, pos int) Symbol
-	AnalyzeValue(n Node) Symbol
+	AnalyzeValue(n SyntaxNode) Symbol
 }
 
 func locateNearestNode(cursor *sitter.TreeCursor, pos Position) *sitter.Node {
diff --git a/symbol_analyzer.go b/symbol_analyzer.go
@@ -42,7 +42,7 @@ func (an *SymbolAnalyzer) captureAndAnalyze(parent *SymbolTree, rootNode *sitter
 		}
 
 		// group first the information
-		captured := map[string]Node{}
+		captured := map[string]SyntaxNode{}
 		firstMatchCname := ""
 		for _, c := range m.Captures {
 			key := q.CaptureNameForId(c.Index)
diff --git a/symbol_tree.go b/symbol_tree.go
@@ -9,7 +9,7 @@ type SymbolTree struct {
 	Scopes       []*SymbolTree
 }
 
-func (tree *SymbolTree) CreateChildFromNode(n Node) *SymbolTree {
+func (tree *SymbolTree) CreateChildFromNode(n SyntaxNode) *SymbolTree {
 	return &SymbolTree{
 		Parent:       tree,
 		StartPos:     n.StartPosition(),

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@ package errgoengine`
`3`	`3`	`type MainError struct {`
`4`	`4`	`ErrorNode *StackTraceEntry`
`5`	`5`	`Document *Document`
`6`		`- Nearest Node`
	`6`	`+ Nearest SyntaxNode`
`7`	`7`	`}`
`8`	`8`
`9`	`9`	`func (err MainError) DocumentPath() string {`
`@@ -40,7 +40,7 @@ func (data *ContextData) FindSymbol(name string, pos int) Symbol {`
`40`	`40`	`return data.Store.FindSymbol(path, name, pos)`
`41`	`41`	`}`
`42`	`42`
`43`		`-func (data *ContextData) AnalyzeValue(n Node) Symbol {`
	`43`	`+func (data *ContextData) AnalyzeValue(n SyntaxNode) Symbol {`
`44`	`44`	`return n.Doc.Language.ValueAnalyzer(data, n)`
`45`	`45`	`}`
`46`	`46`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`package errgoengine`
`2`	`2`
`3`	`3`	`type ImportParams struct {`
`4`		`- Node Node`
	`4`	`+ Node SyntaxNode`
`5`	`5`	`CurrentDir string`
`6`	`6`	`}`
`7`	`7`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ type Language struct {`
`18`	`18`	`ErrorPattern string`
`19`	`19`	`SymbolsToCapture ISymbolCaptureList`
`20`	`20`	`LocationConverter func(path, pos string) Location`
`21`		`- ValueAnalyzer func(NodeValueAnalyzer, Node) Symbol`
	`21`	`+ ValueAnalyzer func(NodeValueAnalyzer, SyntaxNode) Symbol`
`22`	`22`	`ImportResolver func(NodeValueAnalyzer, ImportParams) ResolvedImport`
`23`	`23`	`}`
`24`	`24`
Original file line number	Diff line number	Diff line change
`@@ -4,41 +4,41 @@ import (`
`4`	`4`	`sitter "github.com/smacker/go-tree-sitter"`
`5`	`5`	`)`
`6`	`6`
`7`		`-type Node struct {`
	`7`	`+type SyntaxNode struct {`
`8`	`8`	`*sitter.Node`
`9`	`9`	`Doc *Document`
`10`	`10`	`text string`
`11`	`11`	`}`
`12`	`12`
`13`		`-func (n Node) Text() string {`
	`13`	`+func (n SyntaxNode) Text() string {`
`14`	`14`	`return n.text`
`15`	`15`	`}`
`16`	`16`
`17`		`-func (n Node) ChildByFieldName(field string) Node {`
	`17`	`+func (n SyntaxNode) ChildByFieldName(field string) SyntaxNode {`
`18`	`18`	`cNode := n.Node.ChildByFieldName(field)`
`19`	`19`	`return WrapNode(n.Doc, cNode)`
`20`	`20`	`}`
`21`	`21`
`22`		`-func (n Node) Parent() Node {`
	`22`	`+func (n SyntaxNode) Parent() SyntaxNode {`
`23`	`23`	`return WrapNode(n.Doc, n.Node.Parent())`
`24`	`24`	`}`
`25`	`25`
`26`		`-func (n Node) NamedChild(idx int) Node {`
	`26`	`+func (n SyntaxNode) NamedChild(idx int) SyntaxNode {`
`27`	`27`	`cNode := n.Node.NamedChild(idx)`
`28`	`28`	`return WrapNode(n.Doc, cNode)`
`29`	`29`	`}`
`30`	`30`
`31`		`-func (n Node) LastNamedChild() Node {`
	`31`	`+func (n SyntaxNode) LastNamedChild() SyntaxNode {`
`32`	`32`	`len := n.Node.NamedChildCount()`
`33`	`33`	`return n.NamedChild(int(len) - 1)`
`34`	`34`	`}`
`35`	`35`
`36`		`-func (n Node) Child(idx int) Node {`
	`36`	`+func (n SyntaxNode) Child(idx int) SyntaxNode {`
`37`	`37`	`cNode := n.Node.Child(idx)`
`38`	`38`	`return WrapNode(n.Doc, cNode)`
`39`	`39`	`}`
`40`	`40`
`41`		`-func (n Node) StartPosition() Position {`
	`41`	`+func (n SyntaxNode) StartPosition() Position {`
`42`	`42`	`p := n.Node.StartPoint()`
`43`	`43`	`return Position{`
`44`	`44`	`Line: int(p.Row),`
`@@ -47,7 +47,7 @@ func (n Node) StartPosition() Position {`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`50`		`-func (n Node) EndPosition() Position {`
	`50`	`+func (n SyntaxNode) EndPosition() Position {`
`51`	`51`	`p := n.Node.EndPoint()`
`52`	`52`	`return Position{`
`53`	`53`	`Line: int(p.Row),`
`@@ -56,19 +56,19 @@ func (n Node) EndPosition() Position {`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`59`		`-func (n Node) Location() Location {`
	`59`	`+func (n SyntaxNode) Location() Location {`
`60`	`60`	`return Location{`
`61`	`61`	`DocumentPath: n.Doc.Path,`
`62`	`62`	`Position: n.StartPosition(),`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`
`66`		`-func (n Node) RawNode() *sitter.Node {`
	`66`	`+func (n SyntaxNode) RawNode() *sitter.Node {`
`67`	`67`	`return n.Node`
`68`	`68`	`}`
`69`	`69`
`70`		`-func WrapNode(doc Document, n sitter.Node) Node {`
`71`		`- return Node{`
	`70`	`+func WrapNode(doc Document, n sitter.Node) SyntaxNode {`
	`71`	`+ return SyntaxNode{`
`72`	`72`	`text: n.Content([]byte(doc.Contents)),`
`73`	`73`	`Doc: doc,`
`74`	`74`	`Node: n,`
`@@ -77,7 +77,7 @@ func WrapNode(doc Document, n sitter.Node) Node {`
`77`	`77`
`78`	`78`	`type NodeValueAnalyzer interface {`
`79`	`79`	`FindSymbol(name string, pos int) Symbol`
`80`		`- AnalyzeValue(n Node) Symbol`
	`80`	`+ AnalyzeValue(n SyntaxNode) Symbol`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`func locateNearestNode(cursor sitter.TreeCursor, pos Position) sitter.Node {`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ func (an SymbolAnalyzer) captureAndAnalyze(parent SymbolTree, rootNode *sitter`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`// group first the information`
`45`		`- captured := map[string]Node{}`
	`45`	`+ captured := map[string]SyntaxNode{}`
`46`	`46`	`firstMatchCname := ""`
`47`	`47`	`for _, c := range m.Captures {`
`48`	`48`	`key := q.CaptureNameForId(c.Index)`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ type SymbolTree struct {`
`9`	`9`	`Scopes []*SymbolTree`
`10`	`10`	`}`
`11`	`11`
`12`		`-func (tree SymbolTree) CreateChildFromNode(n Node) SymbolTree {`
	`12`	`+func (tree SymbolTree) CreateChildFromNode(n SyntaxNode) SymbolTree {`
`13`	`13`	`return &SymbolTree{`
`14`	`14`	`Parent: tree,`
`15`	`15`	`StartPos: n.StartPosition(),`