| // Copyright 2023 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package parsego |
| |
| import ( |
| "go/ast" |
| "go/token" |
| "reflect" |
| "testing" |
| ) |
| |
| // oldOffsetPositions is the old clamping logic from before the fix |
| // to the clamping bug in golang/go#64960 |
| func oldOffsetPositions(tok *token.File, n ast.Node, offset token.Pos) { |
| fileBase := token.Pos(tok.Base()) |
| fileEnd := fileBase + token.Pos(tok.Size()) |
| ast.Inspect(n, func(n ast.Node) bool { |
| if n == nil { |
| return false |
| } |
| v := reflect.ValueOf(n).Elem() |
| switch v.Kind() { |
| case reflect.Struct: |
| for _, f := range v.Fields() { |
| |
| if f.Type() != tokenPosType { |
| continue |
| } |
| if !f.CanSet() { |
| continue |
| } |
| pos := token.Pos(f.Int()) |
| if !pos.IsValid() { |
| continue |
| } |
| // Clamp value to valid range; see #64335. |
| // |
| // TODO(golang/go#64335): this is a hack, because our fixes should not |
| // produce positions that overflow (but they do; see golang/go#64488, |
| // #73438, #66790, #66683, #67704). |
| pos = min(max(pos+offset, fileBase), fileEnd) |
| f.SetInt(int64(pos)) |
| } |
| } |
| return true |
| }) |
| } |
| |
| func TestOffsetPositionsClamping(t *testing.T) { |
| // Create a fake token.File of size 10. |
| // Base is 1. File spans [1, 11]. |
| fset := token.NewFileSet() |
| tf := fset.AddFile("test.go", 1, 10) |
| fileBase := token.Pos(tf.Base()) // 1 |
| fileEnd := fileBase + token.Pos(tf.Size()) // 11 |
| |
| // Map a composite literal "variance{}" to the end of the file. |
| // In the file, "variance" is at offset 0 (pos 1). |
| // Lbrace is at pos 9, Rbrace is at pos 10. |
| // Offset is fileEnd (11). |
| |
| t.Run("old_clamping_fails", func(t *testing.T) { |
| cl := &ast.CompositeLit{ |
| Type: &ast.Ident{ |
| Name: "variance", |
| NamePos: 1, |
| }, |
| Lbrace: 9, |
| Rbrace: 10, |
| } |
| // Using the old clamping logic. |
| oldOffsetPositions(tf, cl, 11) |
| |
| // The old logic clamps the start positions of all tokens to fileEnd (11). |
| // This means the identifier "variance" (size 8) starts at 11, so it ends at 19. |
| // 19 is > fileEnd + 1 (12). This is the bug! |
| if int(cl.Type.End()) > tf.Base()+tf.Size()+1 { |
| t.Logf("PASS (demonstrates bug): old clamping results in Type.End() %d > fileEnd+1 %d", cl.Type.End(), tf.Base()+tf.Size()+1) |
| } else { |
| t.Errorf("expected old clamping to fail (Type.End() > fileEnd+1), but got Type.End() = %d", cl.Type.End()) |
| } |
| }) |
| |
| t.Run("new_clamping_passes", func(t *testing.T) { |
| cl := &ast.CompositeLit{ |
| Type: &ast.Ident{ |
| Name: "variance", |
| NamePos: 1, |
| }, |
| Lbrace: 9, |
| Rbrace: 10, |
| } |
| // Using the new clamping logic. |
| offsetPositions(tf, cl, 11) |
| |
| // The new logic clamps NamePos to fileEnd + 1 - len("variance") = 11 + 1 - 8 = 4. |
| expectedPos := fileEnd + 1 - token.Pos(len("variance")) |
| ident := cl.Type.(*ast.Ident) |
| if ident.NamePos != expectedPos { |
| t.Errorf("expected NamePos to be clamped to %d, got %d", expectedPos, ident.NamePos) |
| } |
| |
| // The End() of the identifier is NamePos + 8 = 4 + 8 = 12. |
| // 12 is exactly fileEnd + 1. |
| if int(cl.Type.End()) <= tf.Base()+tf.Size()+1 { |
| t.Logf("PASS: new clamping results in valid Type.End() %d <= fileEnd+1 %d", cl.Type.End(), tf.Base()+tf.Size()+1) |
| } else { |
| t.Errorf("expected new clamping to pass (Type.End() <= fileEnd+1), but got Type.End() = %d", cl.Type.End()) |
| } |
| |
| // Check that the order Lbrace <= Rbrace is preserved. |
| if cl.Lbrace > cl.Rbrace { |
| t.Errorf("Lbrace (%d) should not be greater than Rbrace (%d)", cl.Lbrace, cl.Rbrace) |
| } |
| }) |
| } |
| |
| // exercise all the cases |
| func TestPosSize(t *testing.T) { |
| tests := []struct { |
| node ast.Node |
| field string |
| want int |
| }{ |
| {node: &ast.AssignStmt{Tok: token.DEFINE}, field: "TokPos", want: 2}, |
| {node: &ast.AssignStmt{Tok: token.ASSIGN}, field: "TokPos", want: 1}, |
| // Bad nodes for completeness |
| {node: &ast.BadDecl{From: 10, To: 15}, field: "From", want: 5}, |
| {node: &ast.BadDecl{From: 10, To: 15}, field: "To", want: 0}, |
| {node: &ast.BadExpr{From: 10, To: 15}, field: "From", want: 5}, |
| {node: &ast.BadExpr{From: 10, To: 15}, field: "To", want: 0}, |
| {node: &ast.BadStmt{From: 10, To: 15}, field: "From", want: 5}, |
| {node: &ast.BadStmt{From: 10, To: 15}, field: "To", want: 0}, |
| {node: &ast.BasicLit{Value: `"hello"`, ValuePos: 1}, field: "ValuePos", want: 7}, |
| {node: &ast.BasicLit{Value: `"hello"`, ValuePos: 1}, field: "ValueEnd", want: 0}, |
| {node: &ast.BinaryExpr{Op: token.ADD}, field: "OpPos", want: 1}, |
| {node: &ast.BinaryExpr{Op: token.NEQ}, field: "OpPos", want: 2}, |
| {node: &ast.BlockStmt{}, field: "Lbrace", want: 1}, |
| {node: &ast.BlockStmt{}, field: "Rbrace", want: 1}, |
| {node: &ast.BranchStmt{Tok: token.BREAK}, field: "TokPos", want: 5}, |
| {node: &ast.BranchStmt{Tok: token.FALLTHROUGH}, field: "TokPos", want: 11}, |
| {node: &ast.CallExpr{}, field: "Lparen", want: 1}, |
| {node: &ast.CallExpr{}, field: "Rparen", want: 1}, |
| {node: &ast.CallExpr{}, field: "Ellipsis", want: 3}, |
| {node: &ast.CaseClause{List: []ast.Expr{&ast.Ident{}}}, field: "Case", want: 4}, |
| {node: &ast.CaseClause{List: nil}, field: "Case", want: 7}, |
| {node: &ast.CaseClause{}, field: "Colon", want: 1}, |
| {node: &ast.ChanType{}, field: "Begin", want: 4}, |
| {node: &ast.ChanType{}, field: "Arrow", want: 2}, |
| {node: &ast.CommClause{Comm: &ast.ExprStmt{}}, field: "Case", want: 4}, |
| {node: &ast.CommClause{Comm: nil}, field: "Case", want: 7}, |
| {node: &ast.CommClause{}, field: "Colon", want: 1}, |
| {node: &ast.Comment{Text: "// comment"}, field: "Slash", want: 10}, |
| {node: &ast.CompositeLit{}, field: "Lbrace", want: 1}, |
| {node: &ast.CompositeLit{}, field: "Rbrace", want: 1}, |
| {node: &ast.DeferStmt{}, field: "Defer", want: 5}, |
| {node: &ast.Ellipsis{}, field: "Ellipsis", want: 3}, |
| {node: &ast.EmptyStmt{}, field: "Semicolon", want: 1}, |
| {node: &ast.File{}, field: "Package", want: 7}, |
| {node: &ast.File{}, field: "FileStart", want: 0}, |
| {node: &ast.File{}, field: "FileEnd", want: 0}, |
| {node: &ast.ForStmt{}, field: "For", want: 3}, |
| {node: &ast.FuncType{}, field: "Func", want: 4}, |
| {node: &ast.GenDecl{Tok: token.IMPORT}, field: "TokPos", want: 6}, |
| {node: &ast.GenDecl{}, field: "Lparen", want: 1}, |
| {node: &ast.GenDecl{}, field: "Rparen", want: 1}, |
| {node: &ast.GoStmt{}, field: "Go", want: 2}, |
| {node: &ast.Ident{Name: "foo"}, field: "NamePos", want: 3}, |
| {node: &ast.IfStmt{}, field: "If", want: 2}, |
| {node: &ast.ImportSpec{}, field: "EndPos", want: 0}, |
| {node: &ast.IncDecStmt{Tok: token.INC}, field: "TokPos", want: 2}, |
| {node: &ast.InterfaceType{}, field: "Interface", want: 9}, |
| {node: &ast.KeyValueExpr{}, field: "Colon", want: 1}, |
| {node: &ast.LabeledStmt{}, field: "Colon", want: 1}, |
| {node: &ast.MapType{}, field: "Map", want: 3}, |
| {node: &ast.RangeStmt{}, field: "For", want: 3}, |
| {node: &ast.RangeStmt{Tok: token.DEFINE}, field: "TokPos", want: 2}, |
| // These keyword tests are here for completeess |
| {node: &ast.RangeStmt{}, field: "Range", want: 5}, |
| {node: &ast.ReturnStmt{}, field: "Return", want: 6}, |
| {node: &ast.SelectStmt{}, field: "Select", want: 6}, |
| {node: &ast.SendStmt{}, field: "Arrow", want: 2}, |
| {node: &ast.StructType{}, field: "Struct", want: 6}, |
| {node: &ast.SwitchStmt{}, field: "Switch", want: 6}, |
| {node: &ast.TypeSpec{}, field: "Assign", want: 1}, |
| {node: &ast.TypeSwitchStmt{}, field: "Switch", want: 6}, |
| {node: &ast.UnaryExpr{Op: token.AND}, field: "OpPos", want: 1}, |
| // Fallbacks |
| {node: &ast.Ident{}, field: "UnknownField", want: 1}, |
| {node: &ast.Field{}, field: "Doc", want: 1}, |
| } |
| |
| for _, tc := range tests { |
| got := posSize(tc.node, tc.field) |
| if got != tc.want { |
| t.Errorf("posSize(%T, %q) = %d; want %d", tc.node, tc.field, got, tc.want) |
| } |
| } |
| } |
