src/go/types/errors.go

   1 // Copyright 2012 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // This file implements various error reporters.
   6
   7 package types
   8
   9 import (
  10         "bytes"
  11         "fmt"
  12         "go/ast"
  13         "go/token"
  14         . "internal/types/errors"
  15         "runtime"
  16         "strconv"
  17         "strings"
  18 )
  19
  20 func assert(p bool) {
  21         if !p {
  22                 msg := "assertion failed"
  23                 // Include information about the assertion location. Due to panic recovery,
  24                 // this location is otherwise buried in the middle of the panicking stack.
  25                 if _, file, line, ok := runtime.Caller(1); ok {
  26                         msg = fmt.Sprintf("%s:%d: %s", file, line, msg)
  27                 }
  28                 panic(msg)
  29         }
  30 }
  31
  32 func unreachable() {
  33         panic("unreachable")
  34 }
  35
  36 // An error_ represents a type-checking error.
  37 // To report an error_, call Checker.report.
  38 type error_ struct {
  39         desc []errorDesc
  40         code Code
  41         soft bool // TODO(gri) eventually determine this from an error code
  42 }
  43
  44 // An errorDesc describes part of a type-checking error.
  45 type errorDesc struct {
  46         posn   positioner
  47         format string
  48         args   []interface{}
  49 }
  50
  51 func (err *error_) empty() bool {
  52         return err.desc == nil
  53 }
  54
  55 func (err *error_) pos() token.Pos {
  56         if err.empty() {
  57                 return token.NoPos
  58         }
  59         return err.desc[0].posn.Pos()
  60 }
  61
  62 func (err *error_) msg(fset *token.FileSet, qf Qualifier) string {
  63         if err.empty() {
  64                 return "no error"
  65         }
  66         var buf strings.Builder
  67         for i := range err.desc {
  68                 p := &err.desc[i]
  69                 if i > 0 {
  70                         fmt.Fprint(&buf, "\n\t")
  71                         if p.posn.Pos().IsValid() {
  72                                 fmt.Fprintf(&buf, "%s: ", fset.Position(p.posn.Pos()))
  73                         }
  74                 }
  75                 buf.WriteString(sprintf(fset, qf, false, p.format, p.args...))
  76         }
  77         return buf.String()
  78 }
  79
  80 // String is for testing.
  81 func (err *error_) String() string {
  82         if err.empty() {
  83                 return "no error"
  84         }
  85         return fmt.Sprintf("%d: %s", err.pos(), err.msg(nil, nil))
  86 }
  87
  88 // errorf adds formatted error information to err.
  89 // It may be called multiple times to provide additional information.
  90 func (err *error_) errorf(at token.Pos, format string, args ...interface{}) {
  91         err.desc = append(err.desc, errorDesc{atPos(at), format, args})
  92 }
  93
  94 func (check *Checker) qualifier(pkg *Package) string {
  95         // Qualify the package unless it's the package being type-checked.
  96         if pkg != check.pkg {
  97                 if check.pkgPathMap == nil {
  98                         check.pkgPathMap = make(map[string]map[string]bool)
  99                         check.seenPkgMap = make(map[*Package]bool)
 100                         check.markImports(check.pkg)
 101                 }
 102                 // If the same package name was used by multiple packages, display the full path.
 103                 if len(check.pkgPathMap[pkg.name]) > 1 {
 104                         return strconv.Quote(pkg.path)
 105                 }
 106                 return pkg.name
 107         }
 108         return ""
 109 }
 110
 111 // markImports recursively walks pkg and its imports, to record unique import
 112 // paths in pkgPathMap.
 113 func (check *Checker) markImports(pkg *Package) {
 114         if check.seenPkgMap[pkg] {
 115                 return
 116         }
 117         check.seenPkgMap[pkg] = true
 118
 119         forName, ok := check.pkgPathMap[pkg.name]
 120         if !ok {
 121                 forName = make(map[string]bool)
 122                 check.pkgPathMap[pkg.name] = forName
 123         }
 124         forName[pkg.path] = true
 125
 126         for _, imp := range pkg.imports {
 127                 check.markImports(imp)
 128         }
 129 }
 130
 131 // check may be nil.
 132 func (check *Checker) sprintf(format string, args ...any) string {
 133         var fset *token.FileSet
 134         var qf Qualifier
 135         if check != nil {
 136                 fset = check.fset
 137                 qf = check.qualifier
 138         }
 139         return sprintf(fset, qf, false, format, args...)
 140 }
 141
 142 func sprintf(fset *token.FileSet, qf Qualifier, tpSubscripts bool, format string, args ...any) string {
 143         for i, arg := range args {
 144                 switch a := arg.(type) {
 145                 case nil:
 146                         arg = "<nil>"
 147                 case operand:
 148                         panic("got operand instead of *operand")
 149                 case *operand:
 150                         arg = operandString(a, qf)
 151                 case token.Pos:
 152                         if fset != nil {
 153                                 arg = fset.Position(a).String()
 154                         }
 155                 case ast.Expr:
 156                         arg = ExprString(a)
 157                 case []ast.Expr:
 158                         var buf bytes.Buffer
 159                         buf.WriteByte('[')
 160                         writeExprList(&buf, a)
 161                         buf.WriteByte(']')
 162                         arg = buf.String()
 163                 case Object:
 164                         arg = ObjectString(a, qf)
 165                 case Type:
 166                         var buf bytes.Buffer
 167                         w := newTypeWriter(&buf, qf)
 168                         w.tpSubscripts = tpSubscripts
 169                         w.typ(a)
 170                         arg = buf.String()
 171                 case []Type:
 172                         var buf bytes.Buffer
 173                         w := newTypeWriter(&buf, qf)
 174                         w.tpSubscripts = tpSubscripts
 175                         buf.WriteByte('[')
 176                         for i, x := range a {
 177                                 if i > 0 {
 178                                         buf.WriteString(", ")
 179                                 }
 180                                 w.typ(x)
 181                         }
 182                         buf.WriteByte(']')
 183                         arg = buf.String()
 184                 case []*TypeParam:
 185                         var buf bytes.Buffer
 186                         w := newTypeWriter(&buf, qf)
 187                         w.tpSubscripts = tpSubscripts
 188                         buf.WriteByte('[')
 189                         for i, x := range a {
 190                                 if i > 0 {
 191                                         buf.WriteString(", ")
 192                                 }
 193                                 w.typ(x)
 194                         }
 195                         buf.WriteByte(']')
 196                         arg = buf.String()
 197                 }
 198                 args[i] = arg
 199         }
 200         return fmt.Sprintf(format, args...)
 201 }
 202
 203 func (check *Checker) trace(pos token.Pos, format string, args ...any) {
 204         fmt.Printf("%s:\t%s%s\n",
 205                 check.fset.Position(pos),
 206                 strings.Repeat(".  ", check.indent),
 207                 sprintf(check.fset, check.qualifier, true, format, args...),
 208         )
 209 }
 210
 211 // dump is only needed for debugging
 212 func (check *Checker) dump(format string, args ...any) {
 213         fmt.Println(sprintf(check.fset, check.qualifier, true, format, args...))
 214 }
 215
 216 // Report records the error pointed to by errp, setting check.firstError if
 217 // necessary.
 218 func (check *Checker) report(errp *error_) {
 219         if errp.empty() {
 220                 panic("empty error details")
 221         }
 222
 223         if errp.code == 0 {
 224                 panic("no error code provided")
 225         }
 226
 227         span := spanOf(errp.desc[0].posn)
 228         e := Error{
 229                 Fset:       check.fset,
 230                 Pos:        span.pos,
 231                 Msg:        errp.msg(check.fset, check.qualifier),
 232                 Soft:       errp.soft,
 233                 go116code:  errp.code,
 234                 go116start: span.start,
 235                 go116end:   span.end,
 236         }
 237
 238         // Cheap trick: Don't report errors with messages containing
 239         // "invalid operand" or "invalid type" as those tend to be
 240         // follow-on errors which don't add useful information. Only
 241         // exclude them if these strings are not at the beginning,
 242         // and only if we have at least one error already reported.
 243         isInvalidErr := strings.Index(e.Msg, "invalid operand") > 0 || strings.Index(e.Msg, "invalid type") > 0
 244         if check.firstErr != nil && isInvalidErr {
 245                 return
 246         }
 247
 248         e.Msg = stripAnnotations(e.Msg)
 249         if check.errpos != nil {
 250                 // If we have an internal error and the errpos override is set, use it to
 251                 // augment our error positioning.
 252                 // TODO(rFindley) we may also want to augment the error message and refer
 253                 // to the position (pos) in the original expression.
 254                 span := spanOf(check.errpos)
 255                 e.Pos = span.pos
 256                 e.go116start = span.start
 257                 e.go116end = span.end
 258         }
 259         err := e
 260
 261         if check.firstErr == nil {
 262                 check.firstErr = err
 263         }
 264
 265         if trace {
 266                 pos := e.Pos
 267                 msg := e.Msg
 268                 check.trace(pos, "ERROR: %s", msg)
 269         }
 270
 271         f := check.conf.Error
 272         if f == nil {
 273                 panic(bailout{}) // report only first error
 274         }
 275         f(err)
 276 }
 277
 278 const (
 279         invalidAST = "invalid AST: "
 280         invalidArg = "invalid argument: "
 281         invalidOp  = "invalid operation: "
 282 )
 283
 284 // newErrorf creates a new error_ for later reporting with check.report.
 285 func newErrorf(at positioner, code Code, format string, args ...any) *error_ {
 286         return &error_{
 287                 desc: []errorDesc{{at, format, args}},
 288                 code: code,
 289         }
 290 }
 291
 292 func (check *Checker) error(at positioner, code Code, msg string) {
 293         check.report(newErrorf(at, code, msg))
 294 }
 295
 296 func (check *Checker) errorf(at positioner, code Code, format string, args ...any) {
 297         check.report(newErrorf(at, code, format, args...))
 298 }
 299
 300 func (check *Checker) softErrorf(at positioner, code Code, format string, args ...any) {
 301         err := newErrorf(at, code, format, args...)
 302         err.soft = true
 303         check.report(err)
 304 }
 305
 306 func (check *Checker) versionErrorf(at positioner, goVersion string, format string, args ...interface{}) {
 307         msg := check.sprintf(format, args...)
 308         var err *error_
 309         err = newErrorf(at, UnsupportedFeature, "%s requires %s or later", msg, goVersion)
 310         check.report(err)
 311 }
 312
 313 // The positioner interface is used to extract the position of type-checker
 314 // errors.
 315 type positioner interface {
 316         Pos() token.Pos
 317 }
 318
 319 // posSpan holds a position range along with a highlighted position within that
 320 // range. This is used for positioning errors, with pos by convention being the
 321 // first position in the source where the error is known to exist, and start
 322 // and end defining the full span of syntax being considered when the error was
 323 // detected. Invariant: start <= pos < end || start == pos == end.
 324 type posSpan struct {
 325         start, pos, end token.Pos
 326 }
 327
 328 func (e posSpan) Pos() token.Pos {
 329         return e.pos
 330 }
 331
 332 // inNode creates a posSpan for the given node.
 333 // Invariant: node.Pos() <= pos < node.End() (node.End() is the position of the
 334 // first byte after node within the source).
 335 func inNode(node ast.Node, pos token.Pos) posSpan {
 336         start, end := node.Pos(), node.End()
 337         if debug {
 338                 assert(start <= pos && pos < end)
 339         }
 340         return posSpan{start, pos, end}
 341 }
 342
 343 // atPos wraps a token.Pos to implement the positioner interface.
 344 type atPos token.Pos
 345
 346 func (s atPos) Pos() token.Pos {
 347         return token.Pos(s)
 348 }
 349
 350 // spanOf extracts an error span from the given positioner. By default this is
 351 // the trivial span starting and ending at pos, but this span is expanded when
 352 // the argument naturally corresponds to a span of source code.
 353 func spanOf(at positioner) posSpan {
 354         switch x := at.(type) {
 355         case nil:
 356                 panic("nil positioner")
 357         case posSpan:
 358                 return x
 359         case ast.Node:
 360                 pos := x.Pos()
 361                 return posSpan{pos, pos, x.End()}
 362         case *operand:
 363                 if x.expr != nil {
 364                         pos := x.Pos()
 365                         return posSpan{pos, pos, x.expr.End()}
 366                 }
 367                 return posSpan{token.NoPos, token.NoPos, token.NoPos}
 368         default:
 369                 pos := at.Pos()
 370                 return posSpan{pos, pos, pos}
 371         }
 372 }
 373
 374 // stripAnnotations removes internal (type) annotations from s.
 375 func stripAnnotations(s string) string {
 376         var buf strings.Builder
 377         for _, r := range s {
 378                 // strip #'s and subscript digits
 379                 if r < '₀' || '₀'+10 <= r { // '₀' == U+2080
 380                         buf.WriteRune(r)
 381                 }
 382         }
 383         if buf.Len() < len(s) {
 384                 return buf.String()
 385         }
 386         return s
 387 }