mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
653 lines
16 KiB
Go
653 lines
16 KiB
Go
// Copyright 2017 The Wuffs Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
//go:generate go run gen.go
|
|
|
|
package check
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"math/big"
|
|
"path"
|
|
|
|
"github.com/google/wuffs/lang/base38"
|
|
"github.com/google/wuffs/lang/parse"
|
|
|
|
a "github.com/google/wuffs/lang/ast"
|
|
t "github.com/google/wuffs/lang/token"
|
|
)
|
|
|
|
type Error struct {
|
|
Err error
|
|
Filename string
|
|
Line uint32
|
|
OtherFilename string
|
|
OtherLine uint32
|
|
|
|
TMap *t.Map
|
|
Facts []*a.Expr
|
|
}
|
|
|
|
func (e *Error) Error() string {
|
|
s := ""
|
|
if e.OtherFilename != "" || e.OtherLine != 0 {
|
|
s = fmt.Sprintf("%s at %s:%d and %s:%d",
|
|
e.Err, e.Filename, e.Line, e.OtherFilename, e.OtherLine)
|
|
} else {
|
|
s = fmt.Sprintf("%s at %s:%d", e.Err, e.Filename, e.Line)
|
|
}
|
|
if e.TMap == nil {
|
|
return s
|
|
}
|
|
b := append([]byte(s), ". Facts:\n"...)
|
|
for _, f := range e.Facts {
|
|
b = append(b, '\t')
|
|
b = append(b, f.Str(e.TMap)...)
|
|
b = append(b, '\n')
|
|
}
|
|
return string(b)
|
|
}
|
|
|
|
func Check(tm *t.Map, files []*a.File, resolveUse func(usePath string) ([]byte, error)) (*Checker, error) {
|
|
for _, f := range files {
|
|
if f == nil {
|
|
return nil, errors.New("check: Check given a nil *ast.File")
|
|
}
|
|
}
|
|
|
|
if len(files) > 1 {
|
|
m := map[string]bool{}
|
|
for _, f := range files {
|
|
if m[f.Filename()] {
|
|
return nil, fmt.Errorf("check: Check given duplicate filename %q", f.Filename())
|
|
}
|
|
m[f.Filename()] = true
|
|
}
|
|
}
|
|
|
|
rMap := reasonMap{}
|
|
for _, r := range reasons {
|
|
if id := tm.ByName(r.s); id != 0 {
|
|
rMap[id] = r.r
|
|
}
|
|
}
|
|
c := &Checker{
|
|
tm: tm,
|
|
resolveUse: resolveUse,
|
|
reasonMap: rMap,
|
|
packageID: base38.Max + 1,
|
|
consts: map[t.QID]*a.Const{},
|
|
funcs: map[t.QQID]*a.Func{},
|
|
localVars: map[t.QQID]typeMap{},
|
|
statuses: map[t.QID]*a.Status{},
|
|
structs: map[t.QID]*a.Struct{},
|
|
useBaseNames: map[t.ID]struct{}{},
|
|
}
|
|
|
|
for _, phase := range phases {
|
|
for _, f := range files {
|
|
if phase.kind == a.KInvalid {
|
|
if err := phase.check(c, nil); err != nil {
|
|
return nil, err
|
|
}
|
|
continue
|
|
}
|
|
for _, n := range f.TopLevelDecls() {
|
|
if n.Kind() != phase.kind {
|
|
continue
|
|
}
|
|
if err := phase.check(c, n); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
f.Node().SetTypeChecked()
|
|
}
|
|
}
|
|
return c, nil
|
|
}
|
|
|
|
var phases = [...]struct {
|
|
kind a.Kind
|
|
check func(*Checker, *a.Node) error
|
|
}{
|
|
{a.KPackageID, (*Checker).checkPackageID},
|
|
{a.KInvalid, (*Checker).checkPackageIDExists},
|
|
{a.KUse, (*Checker).checkUse},
|
|
{a.KStatus, (*Checker).checkStatus},
|
|
{a.KConst, (*Checker).checkConst},
|
|
{a.KStruct, (*Checker).checkStructDecl},
|
|
{a.KStruct, (*Checker).checkImplicitResetMethod},
|
|
{a.KInvalid, (*Checker).checkStructCycles},
|
|
{a.KStruct, (*Checker).checkStructFields},
|
|
{a.KFunc, (*Checker).checkFuncSignature},
|
|
{a.KFunc, (*Checker).checkFuncContract},
|
|
{a.KFunc, (*Checker).checkFuncBody},
|
|
{a.KStruct, (*Checker).checkFieldMethodCollisions},
|
|
// TODO: check consts, funcs, structs and uses for name collisions.
|
|
}
|
|
|
|
type reason func(q *checker, n *a.Assert) error
|
|
|
|
type reasonMap map[t.ID]reason
|
|
|
|
type Checker struct {
|
|
tm *t.Map
|
|
resolveUse func(usePath string) ([]byte, error)
|
|
reasonMap reasonMap
|
|
|
|
packageID uint32
|
|
otherPackageID *a.PackageID
|
|
|
|
consts map[t.QID]*a.Const
|
|
funcs map[t.QQID]*a.Func
|
|
localVars map[t.QQID]typeMap
|
|
statuses map[t.QID]*a.Status
|
|
structs map[t.QID]*a.Struct
|
|
|
|
// useBaseNames are the base names of packages referred to by `use
|
|
// "foo/bar"` lines. The keys are `bar`, not `"foo/bar"`.
|
|
useBaseNames map[t.ID]struct{}
|
|
|
|
builtInFuncs map[t.QQID]*a.Func
|
|
builtInSliceFuncs map[t.QQID]*a.Func
|
|
unsortedStructs []*a.Struct
|
|
}
|
|
|
|
func (c *Checker) PackageID() uint32 { return c.packageID }
|
|
|
|
func (c *Checker) checkPackageID(node *a.Node) error {
|
|
n := node.PackageID()
|
|
if c.otherPackageID != nil {
|
|
return &Error{
|
|
Err: fmt.Errorf("check: multiple packageid declarations"),
|
|
Filename: n.Filename(),
|
|
Line: n.Line(),
|
|
OtherFilename: c.otherPackageID.Filename(),
|
|
OtherLine: c.otherPackageID.Line(),
|
|
}
|
|
}
|
|
raw := n.ID().Str(c.tm)
|
|
s, ok := t.Unescape(raw)
|
|
if !ok {
|
|
return &Error{
|
|
Err: fmt.Errorf("check: %q is not a valid packageid", raw),
|
|
Filename: n.Filename(),
|
|
Line: n.Line(),
|
|
}
|
|
}
|
|
u, ok := base38.Encode(s)
|
|
if !ok || u == 0 {
|
|
return &Error{
|
|
Err: fmt.Errorf("check: %q is not a valid packageid", s),
|
|
Filename: n.Filename(),
|
|
Line: n.Line(),
|
|
}
|
|
}
|
|
c.packageID = u
|
|
c.otherPackageID = n
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkPackageIDExists(node *a.Node) error {
|
|
if c.otherPackageID == nil {
|
|
return fmt.Errorf("check: missing packageid declaration")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkUse(node *a.Node) error {
|
|
usePath := node.Use().Path()
|
|
filename, ok := t.Unescape(usePath.Str(c.tm))
|
|
if !ok {
|
|
return fmt.Errorf("check: cannot resolve `use %s`", usePath.Str(c.tm))
|
|
}
|
|
baseName, err := c.tm.Insert(path.Base(filename))
|
|
if err != nil {
|
|
return fmt.Errorf("check: cannot resolve `use %s`: %v", usePath.Str(c.tm), err)
|
|
}
|
|
filename += ".wuffs"
|
|
if _, ok := c.useBaseNames[baseName]; ok {
|
|
return fmt.Errorf("check: duplicate `use \"etc\"` base name %q", baseName.Str(c.tm))
|
|
}
|
|
|
|
if c.resolveUse == nil {
|
|
return fmt.Errorf("check: cannot resolve a use declaration")
|
|
}
|
|
src, err := c.resolveUse(filename)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
tokens, _, err := t.Tokenize(c.tm, filename, src)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
f, err := parse.Parse(c.tm, filename, tokens, &parse.Options{
|
|
AllowDoubleUnderscoreNames: true,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for _, n := range f.TopLevelDecls() {
|
|
if err := n.Raw().SetPackage(c.tm, baseName); err != nil {
|
|
return err
|
|
}
|
|
|
|
duplicate := ""
|
|
switch n.Kind() {
|
|
case a.KConst:
|
|
n := n.Const()
|
|
qid := n.QID()
|
|
if _, ok := c.consts[qid]; ok {
|
|
duplicate = qid.Str(c.tm)
|
|
} else {
|
|
c.consts[qid] = n
|
|
}
|
|
case a.KFunc:
|
|
n := n.Func()
|
|
qqid := n.QQID()
|
|
if _, ok := c.funcs[qqid]; ok {
|
|
duplicate = qqid.Str(c.tm)
|
|
} else {
|
|
c.funcs[qqid] = n
|
|
}
|
|
case a.KStatus:
|
|
n := n.Status()
|
|
qid := n.QID()
|
|
if _, ok := c.statuses[qid]; ok {
|
|
duplicate = qid.Str(c.tm)
|
|
} else {
|
|
c.statuses[qid] = n
|
|
}
|
|
case a.KStruct:
|
|
n := n.Struct()
|
|
qid := n.QID()
|
|
if _, ok := c.structs[qid]; ok {
|
|
duplicate = qid.Str(c.tm)
|
|
} else {
|
|
c.structs[qid] = n
|
|
}
|
|
}
|
|
|
|
if duplicate != "" {
|
|
return fmt.Errorf("check: duplicate name %s", duplicate)
|
|
}
|
|
}
|
|
c.useBaseNames[baseName] = struct{}{}
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkStatus(node *a.Node) error {
|
|
n := node.Status()
|
|
qid := n.QID()
|
|
if other, ok := c.statuses[qid]; ok {
|
|
return &Error{
|
|
Err: fmt.Errorf("check: duplicate status %s", qid.Str(c.tm)),
|
|
Filename: n.Filename(),
|
|
Line: n.Line(),
|
|
OtherFilename: other.Filename(),
|
|
OtherLine: other.Line(),
|
|
}
|
|
}
|
|
c.statuses[qid] = n
|
|
n.Node().SetTypeChecked()
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkConst(node *a.Node) error {
|
|
n := node.Const()
|
|
qid := n.QID()
|
|
if other, ok := c.consts[qid]; ok {
|
|
return &Error{
|
|
Err: fmt.Errorf("check: duplicate const %s", qid.Str(c.tm)),
|
|
Filename: n.Filename(),
|
|
Line: n.Line(),
|
|
OtherFilename: other.Filename(),
|
|
OtherLine: other.Line(),
|
|
}
|
|
}
|
|
c.consts[qid] = n
|
|
|
|
q := &checker{
|
|
c: c,
|
|
tm: c.tm,
|
|
}
|
|
if err := q.tcheckTypeExpr(n.XType(), 0); err != nil {
|
|
return fmt.Errorf("%v in const %s", err, qid.Str(c.tm))
|
|
}
|
|
if err := q.tcheckExpr(n.Value(), 0); err != nil {
|
|
return fmt.Errorf("%v in const %s", err, qid.Str(c.tm))
|
|
}
|
|
|
|
nLists := 0
|
|
typ := n.XType()
|
|
for typ.IsArrayType() {
|
|
if nLists == a.MaxTypeExprDepth {
|
|
return fmt.Errorf("check: type expression recursion depth too large")
|
|
}
|
|
nLists++
|
|
typ = typ.Inner()
|
|
}
|
|
if typ.Decorator() != 0 {
|
|
return fmt.Errorf("check: invalid const type %q for %s", n.XType().Str(c.tm), qid.Str(c.tm))
|
|
}
|
|
nMin, nMax, err := q.bcheckTypeExpr(typ)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if nMin == nil || nMax == nil {
|
|
return fmt.Errorf("check: invalid const type %q for %s", n.XType().Str(c.tm), qid.Str(c.tm))
|
|
}
|
|
if err := c.checkConstElement(n.Value(), nMin, nMax, nLists); err != nil {
|
|
return fmt.Errorf("check: %v for %s", err, qid.Str(c.tm))
|
|
}
|
|
n.Node().SetTypeChecked()
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkConstElement(n *a.Expr, nMin *big.Int, nMax *big.Int, nLists int) error {
|
|
if nLists > 0 {
|
|
nLists--
|
|
if n.Operator() != t.IDDollar {
|
|
return fmt.Errorf("invalid const value %q", n.Str(c.tm))
|
|
}
|
|
for _, o := range n.Args() {
|
|
if err := c.checkConstElement(o.Expr(), nMin, nMax, nLists); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
if cv := n.ConstValue(); cv == nil || cv.Cmp(nMin) < 0 || cv.Cmp(nMax) > 0 {
|
|
return fmt.Errorf("invalid const value %q not within [%v..%v]", n.Str(c.tm), nMin, nMax)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkStructDecl(node *a.Node) error {
|
|
n := node.Struct()
|
|
qid := n.QID()
|
|
if other, ok := c.structs[qid]; ok {
|
|
return &Error{
|
|
Err: fmt.Errorf("check: duplicate struct %s", qid.Str(c.tm)),
|
|
Filename: n.Filename(),
|
|
Line: n.Line(),
|
|
OtherFilename: other.Filename(),
|
|
OtherLine: other.Line(),
|
|
}
|
|
}
|
|
c.structs[qid] = n
|
|
c.unsortedStructs = append(c.unsortedStructs, n)
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkImplicitResetMethod(node *a.Node) error {
|
|
n := node.Struct()
|
|
in := a.NewStruct(0, n.Filename(), n.Line(), t.IDIn, nil)
|
|
out := a.NewStruct(0, n.Filename(), n.Line(), t.IDOut, nil)
|
|
f := a.NewFunc(0, n.Filename(), n.Line(), n.QID()[1], t.IDReset, in, out, nil, nil)
|
|
return c.checkFuncSignature(f.Node())
|
|
}
|
|
|
|
func (c *Checker) checkStructCycles(_ *a.Node) error {
|
|
if _, ok := a.TopologicalSortStructs(c.unsortedStructs); !ok {
|
|
return fmt.Errorf("check: cyclical struct definitions")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkStructFields(node *a.Node) error {
|
|
n := node.Struct()
|
|
if err := c.checkFields(n.Fields(), true); err != nil {
|
|
return &Error{
|
|
Err: fmt.Errorf("%v in struct %s", err, n.QID().Str(c.tm)),
|
|
Filename: n.Filename(),
|
|
Line: n.Line(),
|
|
}
|
|
}
|
|
n.Node().SetTypeChecked()
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkFields(fields []*a.Node, banPtrTypes bool) error {
|
|
if len(fields) == 0 {
|
|
return nil
|
|
}
|
|
|
|
q := &checker{
|
|
c: c,
|
|
tm: c.tm,
|
|
}
|
|
fieldNames := map[t.ID]bool{}
|
|
for _, n := range fields {
|
|
f := n.Field()
|
|
if _, ok := fieldNames[f.Name()]; ok {
|
|
return fmt.Errorf("check: duplicate field %q", f.Name().Str(c.tm))
|
|
}
|
|
if err := q.tcheckTypeExpr(f.XType(), 0); err != nil {
|
|
return fmt.Errorf("%v in field %q", err, f.Name().Str(c.tm))
|
|
}
|
|
if banPtrTypes && f.XType().HasPointers() {
|
|
return fmt.Errorf("check: pointer-containing type %q not allowed for field %q",
|
|
f.XType().Str(c.tm), f.Name().Str(c.tm))
|
|
}
|
|
if dv := f.DefaultValue(); dv != nil {
|
|
if f.XType().Decorator() != 0 {
|
|
return fmt.Errorf("check: cannot set default value for type %q for field %q",
|
|
f.XType().Str(c.tm), f.Name().Str(c.tm))
|
|
}
|
|
if err := q.tcheckExpr(dv, 0); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if err := bcheckField(c.tm, f); err != nil {
|
|
return err
|
|
}
|
|
fieldNames[f.Name()] = true
|
|
f.Node().SetTypeChecked()
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkFuncSignature(node *a.Node) error {
|
|
n := node.Func()
|
|
if err := c.checkFields(n.In().Fields(), false); err != nil {
|
|
return &Error{
|
|
Err: fmt.Errorf("%v in in-params for func %s", err, n.QQID().Str(c.tm)),
|
|
Filename: n.Filename(),
|
|
Line: n.Line(),
|
|
}
|
|
}
|
|
n.In().Node().SetTypeChecked()
|
|
if err := c.checkFields(n.Out().Fields(), false); err != nil {
|
|
return &Error{
|
|
Err: fmt.Errorf("%v in out-params for func %s", err, n.QQID().Str(c.tm)),
|
|
Filename: n.Filename(),
|
|
Line: n.Line(),
|
|
}
|
|
}
|
|
n.Out().Node().SetTypeChecked()
|
|
|
|
// TODO: check somewhere that, if n.Out() is non-empty (or we are
|
|
// suspendible), that we end with a return statement? Or is that an
|
|
// implicit "return out"?
|
|
|
|
qqid := n.QQID()
|
|
if qqid[0] == t.IDBase {
|
|
// No need to populate c.funcs and c.localVars for built-in funcs. In
|
|
// any case, the remaining type checking code in this function doesn't
|
|
// handle the base.◊ diamond type.
|
|
return nil
|
|
}
|
|
if other, ok := c.funcs[qqid]; ok {
|
|
return &Error{
|
|
Err: fmt.Errorf("check: duplicate function %s", qqid.Str(c.tm)),
|
|
Filename: n.Filename(),
|
|
Line: n.Line(),
|
|
OtherFilename: other.Filename(),
|
|
OtherLine: other.Line(),
|
|
}
|
|
}
|
|
|
|
iQID := n.In().QID()
|
|
inTyp := a.NewTypeExpr(0, iQID[0], iQID[1], nil, nil, nil)
|
|
inTyp.Node().SetTypeChecked()
|
|
oQID := n.Out().QID()
|
|
outTyp := a.NewTypeExpr(0, oQID[0], oQID[1], nil, nil, nil)
|
|
outTyp.Node().SetTypeChecked()
|
|
localVars := typeMap{
|
|
t.IDIn: inTyp,
|
|
t.IDOut: outTyp,
|
|
}
|
|
if qqid[1] != 0 {
|
|
if _, ok := c.structs[t.QID{qqid[0], qqid[1]}]; !ok {
|
|
return &Error{
|
|
Err: fmt.Errorf("check: no receiver struct defined for function %s", qqid.Str(c.tm)),
|
|
Filename: n.Filename(),
|
|
Line: n.Line(),
|
|
}
|
|
}
|
|
sTyp := a.NewTypeExpr(0, qqid[0], qqid[1], nil, nil, nil)
|
|
sTyp.Node().SetTypeChecked()
|
|
pTyp := a.NewTypeExpr(t.IDPtr, 0, 0, nil, nil, sTyp)
|
|
pTyp.Node().SetTypeChecked()
|
|
localVars[t.IDThis] = pTyp
|
|
}
|
|
c.funcs[qqid] = n
|
|
c.localVars[qqid] = localVars
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkFuncContract(node *a.Node) error {
|
|
n := node.Func()
|
|
if len(n.Asserts()) == 0 {
|
|
return nil
|
|
}
|
|
q := &checker{
|
|
c: c,
|
|
tm: c.tm,
|
|
}
|
|
for _, o := range n.Asserts() {
|
|
if err := q.tcheckAssert(o.Assert()); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkFuncBody(node *a.Node) error {
|
|
n := node.Func()
|
|
q := &checker{
|
|
c: c,
|
|
tm: c.tm,
|
|
reasonMap: c.reasonMap,
|
|
astFunc: c.funcs[n.QQID()],
|
|
localVars: c.localVars[n.QQID()],
|
|
}
|
|
|
|
// Fill in the TypeMap with all local variables. Note that they have
|
|
// function scope and can be hoisted, JavaScript style, a la
|
|
// https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/var
|
|
if err := q.tcheckVars(n.Body()); err != nil {
|
|
return &Error{
|
|
Err: err,
|
|
Filename: q.errFilename,
|
|
Line: q.errLine,
|
|
}
|
|
}
|
|
|
|
// TODO: check that variables are never used before they're initialized.
|
|
|
|
// Assign ConstValue's (if applicable) and MType's to each Expr.
|
|
for _, o := range n.Body() {
|
|
if err := q.tcheckStatement(o); err != nil {
|
|
return &Error{
|
|
Err: err,
|
|
Filename: q.errFilename,
|
|
Line: q.errLine,
|
|
}
|
|
}
|
|
}
|
|
|
|
if err := q.bcheckBlock(n.Body()); err != nil {
|
|
return &Error{
|
|
Err: err,
|
|
Filename: q.errFilename,
|
|
Line: q.errLine,
|
|
TMap: c.tm,
|
|
Facts: q.facts,
|
|
}
|
|
}
|
|
|
|
n.Node().SetTypeChecked()
|
|
if err := n.Node().Walk(func(o *a.Node) error {
|
|
if !o.TypeChecked() {
|
|
switch o.Kind() {
|
|
case a.KExpr:
|
|
return fmt.Errorf("check: internal error: unchecked %s node %q",
|
|
o.Kind(), o.Expr().Str(q.tm))
|
|
case a.KTypeExpr:
|
|
return fmt.Errorf("check: internal error: unchecked %s node %q",
|
|
o.Kind(), o.TypeExpr().Str(q.tm))
|
|
}
|
|
return fmt.Errorf("check: internal error: unchecked %s node", o.Kind())
|
|
}
|
|
if o.Kind() == a.KExpr {
|
|
o := o.Expr()
|
|
if typ := o.MType(); typ == nil {
|
|
return fmt.Errorf("check: internal error: expression %q has no (implicit) type",
|
|
o.Str(q.tm))
|
|
} else if typ.IsIdeal() && o.ConstValue() == nil {
|
|
return fmt.Errorf("check: internal error: expression %q has ideal number type "+
|
|
"but no const value", o.Str(q.tm))
|
|
}
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkFieldMethodCollisions(node *a.Node) error {
|
|
n := node.Struct()
|
|
for _, o := range n.Fields() {
|
|
nQID := n.QID()
|
|
qqid := t.QQID{nQID[0], nQID[1], o.Field().Name()}
|
|
if _, ok := c.funcs[qqid]; ok {
|
|
return fmt.Errorf("check: struct %q has both a field and method named %q",
|
|
nQID.Str(c.tm), qqid[2].Str(c.tm))
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type checker struct {
|
|
c *Checker
|
|
tm *t.Map
|
|
reasonMap reasonMap
|
|
astFunc *a.Func
|
|
localVars typeMap
|
|
|
|
errFilename string
|
|
errLine uint32
|
|
|
|
jumpTargets []a.Loop
|
|
|
|
facts facts
|
|
}
|