errors.go

Documentation: go/types

		 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  	"errors"
		11  	"fmt"
		12  	"go/ast"
		13  	"go/token"
		14  	"strconv"
		15  	"strings"
		16  )
		17  
		18  func assert(p bool) {
		19  	if !p {
		20  		panic("assertion failed")
		21  	}
		22  }
		23  
		24  func unreachable() {
		25  	panic("unreachable")
		26  }
		27  
		28  func (check *Checker) qualifier(pkg *Package) string {
		29  	// Qualify the package unless it's the package being type-checked.
		30  	if pkg != check.pkg {
		31  		if check.pkgPathMap == nil {
		32  			check.pkgPathMap = make(map[string]map[string]bool)
		33  			check.seenPkgMap = make(map[*Package]bool)
		34  			check.markImports(check.pkg)
		35  		}
		36  		// If the same package name was used by multiple packages, display the full path.
		37  		if len(check.pkgPathMap[pkg.name]) > 1 {
		38  			return strconv.Quote(pkg.path)
		39  		}
		40  		return pkg.name
		41  	}
		42  	return ""
		43  }
		44  
		45  // markImports recursively walks pkg and its imports, to record unique import
		46  // paths in pkgPathMap.
		47  func (check *Checker) markImports(pkg *Package) {
		48  	if check.seenPkgMap[pkg] {
		49  		return
		50  	}
		51  	check.seenPkgMap[pkg] = true
		52  
		53  	forName, ok := check.pkgPathMap[pkg.name]
		54  	if !ok {
		55  		forName = make(map[string]bool)
		56  		check.pkgPathMap[pkg.name] = forName
		57  	}
		58  	forName[pkg.path] = true
		59  
		60  	for _, imp := range pkg.imports {
		61  		check.markImports(imp)
		62  	}
		63  }
		64  
		65  func (check *Checker) sprintf(format string, args ...interface{}) string {
		66  	for i, arg := range args {
		67  		switch a := arg.(type) {
		68  		case nil:
		69  			arg = "<nil>"
		70  		case operand:
		71  			panic("internal error: should always pass *operand")
		72  		case *operand:
		73  			arg = operandString(a, check.qualifier)
		74  		case token.Pos:
		75  			arg = check.fset.Position(a).String()
		76  		case ast.Expr:
		77  			arg = ExprString(a)
		78  		case Object:
		79  			arg = ObjectString(a, check.qualifier)
		80  		case Type:
		81  			arg = TypeString(a, check.qualifier)
		82  		}
		83  		args[i] = arg
		84  	}
		85  	return fmt.Sprintf(format, args...)
		86  }
		87  
		88  func (check *Checker) trace(pos token.Pos, format string, args ...interface{}) {
		89  	fmt.Printf("%s:\t%s%s\n",
		90  		check.fset.Position(pos),
		91  		strings.Repeat(".	", check.indent),
		92  		check.sprintf(format, args...),
		93  	)
		94  }
		95  
		96  // dump is only needed for debugging
		97  func (check *Checker) dump(format string, args ...interface{}) {
		98  	fmt.Println(check.sprintf(format, args...))
		99  }
	 100  
	 101  func (check *Checker) err(err error) {
	 102  	if err == nil {
	 103  		return
	 104  	}
	 105  	var e Error
	 106  	isInternal := errors.As(err, &e)
	 107  	// Cheap trick: Don't report errors with messages containing
	 108  	// "invalid operand" or "invalid type" as those tend to be
	 109  	// follow-on errors which don't add useful information. Only
	 110  	// exclude them if these strings are not at the beginning,
	 111  	// and only if we have at least one error already reported.
	 112  	isInvalidErr := isInternal && (strings.Index(e.Msg, "invalid operand") > 0 || strings.Index(e.Msg, "invalid type") > 0)
	 113  	if check.firstErr != nil && isInvalidErr {
	 114  		return
	 115  	}
	 116  
	 117  	if isInternal {
	 118  		e.Msg = stripAnnotations(e.Msg)
	 119  		if check.errpos != nil {
	 120  			// If we have an internal error and the errpos override is set, use it to
	 121  			// augment our error positioning.
	 122  			// TODO(rFindley) we may also want to augment the error message and refer
	 123  			// to the position (pos) in the original expression.
	 124  			span := spanOf(check.errpos)
	 125  			e.Pos = span.pos
	 126  			e.go116start = span.start
	 127  			e.go116end = span.end
	 128  		}
	 129  		err = e
	 130  	}
	 131  
	 132  	if check.firstErr == nil {
	 133  		check.firstErr = err
	 134  	}
	 135  
	 136  	if trace {
	 137  		pos := e.Pos
	 138  		msg := e.Msg
	 139  		if !isInternal {
	 140  			msg = err.Error()
	 141  			pos = token.NoPos
	 142  		}
	 143  		check.trace(pos, "ERROR: %s", msg)
	 144  	}
	 145  
	 146  	f := check.conf.Error
	 147  	if f == nil {
	 148  		panic(bailout{}) // report only first error
	 149  	}
	 150  	f(err)
	 151  }
	 152  
	 153  func (check *Checker) newError(at positioner, code errorCode, soft bool, msg string) error {
	 154  	span := spanOf(at)
	 155  	return Error{
	 156  		Fset:			 check.fset,
	 157  		Pos:				span.pos,
	 158  		Msg:				msg,
	 159  		Soft:			 soft,
	 160  		go116code:	code,
	 161  		go116start: span.start,
	 162  		go116end:	 span.end,
	 163  	}
	 164  }
	 165  
	 166  // newErrorf creates a new Error, but does not handle it.
	 167  func (check *Checker) newErrorf(at positioner, code errorCode, soft bool, format string, args ...interface{}) error {
	 168  	msg := check.sprintf(format, args...)
	 169  	return check.newError(at, code, soft, msg)
	 170  }
	 171  
	 172  func (check *Checker) error(at positioner, code errorCode, msg string) {
	 173  	check.err(check.newError(at, code, false, msg))
	 174  }
	 175  
	 176  func (check *Checker) errorf(at positioner, code errorCode, format string, args ...interface{}) {
	 177  	check.error(at, code, check.sprintf(format, args...))
	 178  }
	 179  
	 180  func (check *Checker) softErrorf(at positioner, code errorCode, format string, args ...interface{}) {
	 181  	check.err(check.newErrorf(at, code, true, format, args...))
	 182  }
	 183  
	 184  func (check *Checker) invalidAST(at positioner, format string, args ...interface{}) {
	 185  	check.errorf(at, 0, "invalid AST: "+format, args...)
	 186  }
	 187  
	 188  func (check *Checker) invalidArg(at positioner, code errorCode, format string, args ...interface{}) {
	 189  	check.errorf(at, code, "invalid argument: "+format, args...)
	 190  }
	 191  
	 192  func (check *Checker) invalidOp(at positioner, code errorCode, format string, args ...interface{}) {
	 193  	check.errorf(at, code, "invalid operation: "+format, args...)
	 194  }
	 195  
	 196  // The positioner interface is used to extract the position of type-checker
	 197  // errors.
	 198  type positioner interface {
	 199  	Pos() token.Pos
	 200  }
	 201  
	 202  // posSpan holds a position range along with a highlighted position within that
	 203  // range. This is used for positioning errors, with pos by convention being the
	 204  // first position in the source where the error is known to exist, and start
	 205  // and end defining the full span of syntax being considered when the error was
	 206  // detected. Invariant: start <= pos < end || start == pos == end.
	 207  type posSpan struct {
	 208  	start, pos, end token.Pos
	 209  }
	 210  
	 211  func (e posSpan) Pos() token.Pos {
	 212  	return e.pos
	 213  }
	 214  
	 215  // inNode creates a posSpan for the given node.
	 216  // Invariant: node.Pos() <= pos < node.End() (node.End() is the position of the
	 217  // first byte after node within the source).
	 218  func inNode(node ast.Node, pos token.Pos) posSpan {
	 219  	start, end := node.Pos(), node.End()
	 220  	if debug {
	 221  		assert(start <= pos && pos < end)
	 222  	}
	 223  	return posSpan{start, pos, end}
	 224  }
	 225  
	 226  // atPos wraps a token.Pos to implement the positioner interface.
	 227  type atPos token.Pos
	 228  
	 229  func (s atPos) Pos() token.Pos {
	 230  	return token.Pos(s)
	 231  }
	 232  
	 233  // spanOf extracts an error span from the given positioner. By default this is
	 234  // the trivial span starting and ending at pos, but this span is expanded when
	 235  // the argument naturally corresponds to a span of source code.
	 236  func spanOf(at positioner) posSpan {
	 237  	switch x := at.(type) {
	 238  	case nil:
	 239  		panic("internal error: nil")
	 240  	case posSpan:
	 241  		return x
	 242  	case ast.Node:
	 243  		pos := x.Pos()
	 244  		return posSpan{pos, pos, x.End()}
	 245  	case *operand:
	 246  		if x.expr != nil {
	 247  			pos := x.Pos()
	 248  			return posSpan{pos, pos, x.expr.End()}
	 249  		}
	 250  		return posSpan{token.NoPos, token.NoPos, token.NoPos}
	 251  	default:
	 252  		pos := at.Pos()
	 253  		return posSpan{pos, pos, pos}
	 254  	}
	 255  }
	 256  
	 257  // stripAnnotations removes internal (type) annotations from s.
	 258  func stripAnnotations(s string) string {
	 259  	var b strings.Builder
	 260  	for _, r := range s {
	 261  		// strip #'s and subscript digits
	 262  		if r != instanceMarker && !('₀' <= r && r < '₀'+10) { // '₀' == U+2080
	 263  			b.WriteRune(r)
	 264  		}
	 265  	}
	 266  	if b.Len() < len(s) {
	 267  		return b.String()
	 268  	}
	 269  	return s
	 270  }
	 271
View as plain text