qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-26 07:38:00 -07:00
Code Releases Activity

cmd/compile/internal/types2: remove 'strict' argument from several methods

Browse Source 
The value is always 'false'. Brings the code closer in line with go/types.
Follow-up on https://golang.org/cl/304129.

Change-Id: I8bea550033f3187b44e9a54258e0cf642c11c369
Reviewed-on: https://go-review.googlesource.com/c/go/+/304849
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
This commit is contained in:
Robert Griesemer 2021-03-25 12:31:25 -07:00
parent 8f676144ad
commit 2abf280a28
4 changed files with 11 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/cmd/compile/internal/types2/api.go
View File

@ -405,7 +405,7 @@ func (conf *Config) Check(path string, files []*syntax.File, info *Info) (*Packa
// AssertableTo reports whether a value of type V can be asserted to have type T. // AssertableTo reports whether a value of type V can be asserted to have type T.
func AssertableTo(V *Interface, T Type) bool { func AssertableTo(V *Interface, T Type) bool {
m, _ := (*Checker)(nil).assertableTo(V, T, false) m, _ := (*Checker)(nil).assertableTo(V, T)
return m == nil return m == nil
} }

6
src/cmd/compile/internal/types2/expr.go
View File

@ -1790,7 +1790,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
if T == Typ[Invalid] { if T == Typ[Invalid] {
goto Error goto Error
} }
check.typeAssertion(posFor(x), x, xtyp, T, false) check.typeAssertion(posFor(x), x, xtyp, T)
x.mode = commaok x.mode = commaok
x.typ = T x.typ = T
@ -1916,8 +1916,8 @@ func keyVal(x constant.Value) interface{} {
} }
// typeAssertion checks that x.(T) is legal; xtyp must be the type of x. // typeAssertion checks that x.(T) is legal; xtyp must be the type of x.
func (check *Checker) typeAssertion(pos syntax.Pos, x *operand, xtyp *Interface, T Type, strict bool) { func (check *Checker) typeAssertion(pos syntax.Pos, x *operand, xtyp *Interface, T Type) {
method, wrongType := check.assertableTo(xtyp, T, strict) method, wrongType := check.assertableTo(xtyp, T)
if method == nil { if method == nil {
return return
} }

8
src/cmd/compile/internal/types2/lookup.go
View File

@ -427,13 +427,13 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
// method required by V and whether it is missing or just has the wrong type. // method required by V and whether it is missing or just has the wrong type.
// The receiver may be nil if assertableTo is invoked through an exported API call // The receiver may be nil if assertableTo is invoked through an exported API call
// (such as AssertableTo), i.e., when all methods have been type-checked. // (such as AssertableTo), i.e., when all methods have been type-checked.
// If strict (or the global constant forceStrict) is set, assertions that // If the global constant forceStrict is set, assertions that are known to fail
// are known to fail are not permitted. // are not permitted.
func (check *Checker) assertableTo(V *Interface, T Type, strict bool) (method, wrongType *Func) { func (check *Checker) assertableTo(V *Interface, T Type) (method, wrongType *Func) {
// no static check is required if T is an interface // no static check is required if T is an interface
// spec: "If T is an interface type, x.(T) asserts that the // spec: "If T is an interface type, x.(T) asserts that the
// dynamic type of x implements the interface T." // dynamic type of x implements the interface T."
if asInterface(T) != nil && !(strict || forceStrict) { if asInterface(T) != nil && !forceStrict {
return return
} }
return check.missingMethod(T, V, false) return check.missingMethod(T, V, false)

6
src/cmd/compile/internal/types2/stmt.go
View File

@ -265,7 +265,7 @@ L:
} }
} }
func (check *Checker) caseTypes(x *operand, xtyp *Interface, types []syntax.Expr, seen map[Type]syntax.Pos, strict bool) (T Type) { func (check *Checker) caseTypes(x *operand, xtyp *Interface, types []syntax.Expr, seen map[Type]syntax.Pos) (T Type) {
L: L:
for _, e := range types { for _, e := range types {
T = check.typOrNil(e) T = check.typOrNil(e)
@ -293,7 +293,7 @@ L:
} }
seen[T] = e.Pos() seen[T] = e.Pos()
if T != nil { if T != nil {
check.typeAssertion(e.Pos(), x, xtyp, T, strict) check.typeAssertion(e.Pos(), x, xtyp, T)
} }
} }
return return
@ -708,7 +708,7 @@ func (check *Checker) typeSwitchStmt(inner stmtContext, s *syntax.SwitchStmt, gu
} }
// Check each type in this type switch case. // Check each type in this type switch case.
cases := unpackExpr(clause.Cases) cases := unpackExpr(clause.Cases)
T := check.caseTypes(&x, xtyp, cases, seen, false) T := check.caseTypes(&x, xtyp, cases, seen)
check.openScopeUntil(clause, end, "case") check.openScopeUntil(clause, end, "case")
// If lhs exists, declare a corresponding variable in the case-local scope. // If lhs exists, declare a corresponding variable in the case-local scope.
if lhs != nil { if lhs != nil {