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 types2
     8  
     9  import (
    10  	"bytes"
    11  	"cmd/compile/internal/syntax"
    12  	"fmt"
    13  	"strconv"
    14  	"strings"
    15  )
    16  
    17  func unimplemented() {
    18  	panic("unimplemented")
    19  }
    20  
    21  func assert(p bool) {
    22  	if !p {
    23  		panic("assertion failed")
    24  	}
    25  }
    26  
    27  func unreachable() {
    28  	panic("unreachable")
    29  }
    30  
    31  // An error_ represents a type-checking error.
    32  // To report an error_, call Checker.report.
    33  type error_ struct {
    34  	desc []errorDesc
    35  	soft bool // TODO(gri) eventually determine this from an error code
    36  }
    37  
    38  // An errorDesc describes part of a type-checking error.
    39  type errorDesc struct {
    40  	pos    syntax.Pos
    41  	format string
    42  	args   []interface{}
    43  }
    44  
    45  func (err *error_) empty() bool {
    46  	return err.desc == nil
    47  }
    48  
    49  func (err *error_) pos() syntax.Pos {
    50  	if err.empty() {
    51  		return nopos
    52  	}
    53  	return err.desc[0].pos
    54  }
    55  
    56  func (err *error_) msg(qf Qualifier) string {
    57  	if err.empty() {
    58  		return "no error"
    59  	}
    60  	var buf bytes.Buffer
    61  	for i := range err.desc {
    62  		p := &err.desc[i]
    63  		if i > 0 {
    64  			fmt.Fprint(&buf, "\n\t")
    65  			if p.pos.IsKnown() {
    66  				fmt.Fprintf(&buf, "%s: ", p.pos)
    67  			}
    68  		}
    69  		buf.WriteString(sprintf(qf, false, p.format, p.args...))
    70  	}
    71  	return buf.String()
    72  }
    73  
    74  // String is for testing.
    75  func (err *error_) String() string {
    76  	if err.empty() {
    77  		return "no error"
    78  	}
    79  	return fmt.Sprintf("%s: %s", err.pos(), err.msg(nil))
    80  }
    81  
    82  // errorf adds formatted error information to err.
    83  // It may be called multiple times to provide additional information.
    84  func (err *error_) errorf(at poser, format string, args ...interface{}) {
    85  	err.desc = append(err.desc, errorDesc{posFor(at), format, args})
    86  }
    87  
    88  func sprintf(qf Qualifier, debug bool, format string, args ...interface{}) string {
    89  	for i, arg := range args {
    90  		switch a := arg.(type) {
    91  		case nil:
    92  			arg = "<nil>"
    93  		case operand:
    94  			panic("got operand instead of *operand")
    95  		case *operand:
    96  			arg = operandString(a, qf)
    97  		case syntax.Pos:
    98  			arg = a.String()
    99  		case syntax.Expr:
   100  			arg = syntax.String(a)
   101  		case []syntax.Expr:
   102  			var buf bytes.Buffer
   103  			buf.WriteByte('[')
   104  			for i, x := range a {
   105  				if i > 0 {
   106  					buf.WriteString(", ")
   107  				}
   108  				buf.WriteString(syntax.String(x))
   109  			}
   110  			buf.WriteByte(']')
   111  			arg = buf.String()
   112  		case Object:
   113  			arg = ObjectString(a, qf)
   114  		case Type:
   115  			arg = typeString(a, qf, debug)
   116  		case []Type:
   117  			var buf bytes.Buffer
   118  			buf.WriteByte('[')
   119  			for i, x := range a {
   120  				if i > 0 {
   121  					buf.WriteString(", ")
   122  				}
   123  				buf.WriteString(typeString(x, qf, debug))
   124  			}
   125  			buf.WriteByte(']')
   126  			arg = buf.String()
   127  		case []*TypeParam:
   128  			var buf bytes.Buffer
   129  			buf.WriteByte('[')
   130  			for i, x := range a {
   131  				if i > 0 {
   132  					buf.WriteString(", ")
   133  				}
   134  				buf.WriteString(typeString(x, qf, debug)) // use typeString so we get subscripts when debugging
   135  			}
   136  			buf.WriteByte(']')
   137  			arg = buf.String()
   138  		}
   139  		args[i] = arg
   140  	}
   141  	return fmt.Sprintf(format, args...)
   142  }
   143  
   144  func (check *Checker) qualifier(pkg *Package) string {
   145  	// Qualify the package unless it's the package being type-checked.
   146  	if pkg != check.pkg {
   147  		if check.pkgPathMap == nil {
   148  			check.pkgPathMap = make(map[string]map[string]bool)
   149  			check.seenPkgMap = make(map[*Package]bool)
   150  			check.markImports(check.pkg)
   151  		}
   152  		// If the same package name was used by multiple packages, display the full path.
   153  		if len(check.pkgPathMap[pkg.name]) > 1 {
   154  			return strconv.Quote(pkg.path)
   155  		}
   156  		return pkg.name
   157  	}
   158  	return ""
   159  }
   160  
   161  // markImports recursively walks pkg and its imports, to record unique import
   162  // paths in pkgPathMap.
   163  func (check *Checker) markImports(pkg *Package) {
   164  	if check.seenPkgMap[pkg] {
   165  		return
   166  	}
   167  	check.seenPkgMap[pkg] = true
   168  
   169  	forName, ok := check.pkgPathMap[pkg.name]
   170  	if !ok {
   171  		forName = make(map[string]bool)
   172  		check.pkgPathMap[pkg.name] = forName
   173  	}
   174  	forName[pkg.path] = true
   175  
   176  	for _, imp := range pkg.imports {
   177  		check.markImports(imp)
   178  	}
   179  }
   180  
   181  // check may be nil.
   182  func (check *Checker) sprintf(format string, args ...interface{}) string {
   183  	var qf Qualifier
   184  	if check != nil {
   185  		qf = check.qualifier
   186  	}
   187  	return sprintf(qf, false, format, args...)
   188  }
   189  
   190  func (check *Checker) report(err *error_) {
   191  	if err.empty() {
   192  		panic("no error to report")
   193  	}
   194  	check.err(err.pos(), err.msg(check.qualifier), err.soft)
   195  }
   196  
   197  func (check *Checker) trace(pos syntax.Pos, format string, args ...interface{}) {
   198  	fmt.Printf("%s:\t%s%s\n",
   199  		pos,
   200  		strings.Repeat(".  ", check.indent),
   201  		sprintf(check.qualifier, true, format, args...),
   202  	)
   203  }
   204  
   205  // dump is only needed for debugging
   206  func (check *Checker) dump(format string, args ...interface{}) {
   207  	fmt.Println(sprintf(check.qualifier, true, format, args...))
   208  }
   209  
   210  func (check *Checker) err(at poser, msg string, soft bool) {
   211  	// Cheap trick: Don't report errors with messages containing
   212  	// "invalid operand" or "invalid type" as those tend to be
   213  	// follow-on errors which don't add useful information. Only
   214  	// exclude them if these strings are not at the beginning,
   215  	// and only if we have at least one error already reported.
   216  	if check.firstErr != nil && (strings.Index(msg, "invalid operand") > 0 || strings.Index(msg, "invalid type") > 0) {
   217  		return
   218  	}
   219  
   220  	pos := posFor(at)
   221  
   222  	// If we are encountering an error while evaluating an inherited
   223  	// constant initialization expression, pos is the position of in
   224  	// the original expression, and not of the currently declared
   225  	// constant identifier. Use the provided errpos instead.
   226  	// TODO(gri) We may also want to augment the error message and
   227  	// refer to the position (pos) in the original expression.
   228  	if check.errpos.IsKnown() {
   229  		assert(check.iota != nil)
   230  		pos = check.errpos
   231  	}
   232  
   233  	err := Error{pos, stripAnnotations(msg), msg, soft}
   234  	if check.firstErr == nil {
   235  		check.firstErr = err
   236  	}
   237  
   238  	if check.conf.Trace {
   239  		check.trace(pos, "ERROR: %s", msg)
   240  	}
   241  
   242  	f := check.conf.Error
   243  	if f == nil {
   244  		panic(bailout{}) // report only first error
   245  	}
   246  	f(err)
   247  }
   248  
   249  const (
   250  	invalidAST = "invalid AST: "
   251  	invalidArg = "invalid argument: "
   252  	invalidOp  = "invalid operation: "
   253  )
   254  
   255  type poser interface {
   256  	Pos() syntax.Pos
   257  }
   258  
   259  func (check *Checker) error(at poser, msg string) {
   260  	check.err(at, msg, false)
   261  }
   262  
   263  func (check *Checker) errorf(at poser, format string, args ...interface{}) {
   264  	check.err(at, check.sprintf(format, args...), false)
   265  }
   266  
   267  func (check *Checker) softErrorf(at poser, format string, args ...interface{}) {
   268  	check.err(at, check.sprintf(format, args...), true)
   269  }
   270  
   271  func (check *Checker) versionErrorf(at poser, goVersion string, format string, args ...interface{}) {
   272  	msg := check.sprintf(format, args...)
   273  	if check.conf.CompilerErrorMessages {
   274  		msg = fmt.Sprintf("%s requires %s or later (-lang was set to %s; check go.mod)", msg, goVersion, check.conf.GoVersion)
   275  	} else {
   276  		msg = fmt.Sprintf("%s requires %s or later", msg, goVersion)
   277  	}
   278  	check.err(at, msg, true)
   279  }
   280  
   281  // posFor reports the left (= start) position of at.
   282  func posFor(at poser) syntax.Pos {
   283  	switch x := at.(type) {
   284  	case *operand:
   285  		if x.expr != nil {
   286  			return syntax.StartPos(x.expr)
   287  		}
   288  	case syntax.Node:
   289  		return syntax.StartPos(x)
   290  	}
   291  	return at.Pos()
   292  }
   293  
   294  // stripAnnotations removes internal (type) annotations from s.
   295  func stripAnnotations(s string) string {
   296  	// Would like to use strings.Builder but it's not available in Go 1.4.
   297  	var b bytes.Buffer
   298  	for _, r := range s {
   299  		// strip #'s and subscript digits
   300  		if r < '₀' || '₀'+10 <= r { // '₀' == U+2080
   301  			b.WriteRune(r)
   302  		}
   303  	}
   304  	if b.Len() < len(s) {
   305  		return b.String()
   306  	}
   307  	return s
   308  }
   309
View as plain text