summaryrefslogtreecommitdiff
path: root/vendor/modernc.org/gc/v3/check.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/modernc.org/gc/v3/check.go')
-rw-r--r--vendor/modernc.org/gc/v3/check.go598
1 files changed, 0 insertions, 598 deletions
diff --git a/vendor/modernc.org/gc/v3/check.go b/vendor/modernc.org/gc/v3/check.go
deleted file mode 100644
index 0c5e0a260..000000000
--- a/vendor/modernc.org/gc/v3/check.go
+++ /dev/null
@@ -1,598 +0,0 @@
-// Copyright 2022 The Gc Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gc // modernc.org/gc/v3
-
-import (
- "fmt"
- "go/constant"
- "go/token"
- "os"
- "path/filepath"
- "strings"
- "sync"
-)
-
-type ctx struct {
- ast *AST
- cfg *Config
- errs errList
- iota int64
- pkg *Package
-
- int32 Type // Set by newCtx
- untypedFloat Type // Set by newCtx
- untypedInt Type // Set by newCtx
- untypedString Type // Set by newCtx
-}
-
-func newCtx(cfg *Config) (r *ctx) {
- r = &ctx{
- cfg: cfg,
- iota: -1, // -> Invalid
- }
- r.int32 = r.newPredeclaredType(znode, Int32)
- r.untypedFloat = r.newPredeclaredType(znode, UntypedFloat)
- r.untypedInt = r.newPredeclaredType(znode, UntypedInt)
- r.untypedString = r.newPredeclaredType(znode, UntypedString)
- return r
-}
-
-func (c *ctx) err(n Node, msg string, args ...interface{}) {
- var pos token.Position
- if n != nil {
- pos = n.Position()
- }
- s := fmt.Sprintf(msg, args...)
- if trcTODOs && strings.HasPrefix(s, "TODO") {
- fmt.Fprintf(os.Stderr, "%v: %s (%v)\n", pos, s, origin(2))
- os.Stderr.Sync()
- }
- switch {
- case extendedErrors:
- c.errs.err(pos, "%s (%v: %v: %v)", s, origin(4), origin(3), origin(2))
- default:
- c.errs.err(pos, s)
- }
-}
-
-func (c *ctx) isBuiltin() bool { return c.pkg.Scope.kind == UniverseScope }
-func (c *ctx) isUnsafe() bool { return c.pkg.isUnsafe }
-
-func (c *ctx) lookup(sc *Scope, id Token) (pkg *Package, in *Scope, r named) {
- sc0 := sc
- pkg = c.pkg
- for {
- switch in, nm := sc.lookup(id); x := nm.n.(type) {
- case *TypeDefNode:
- if sc.kind == UniverseScope {
- if sc0.kind != UniverseScope && token.IsExported(id.Src()) {
- // trc("%v: %q %v %v", id.Position(), id.Src(), sc0.kind, sc.kind)
- return nil, nil, r
- }
- }
-
- return x.pkg, in, nm
- default:
- panic(todo("%v: %q %T", id.Position(), id.Src(), x))
- }
- }
-}
-
-func (n *Package) check(c *ctx) (err error) {
- if n == nil {
- return nil
- }
-
- c.pkg = n
- // trc("PKG %q", n.ImportPath)
- // defer func() { trc("PKG %q -> err: %v", n.ImportPath, err) }()
- for _, v := range n.GoFiles {
- path := filepath.Join(n.FSPath, v.Name())
- n.AST[path].check(c)
- }
- return c.errs.Err()
-}
-
-func (n *AST) check(c *ctx) {
- if n == nil {
- return
- }
-
- c.ast = n
- n.SourceFile.check(c)
-}
-
-func (n *SourceFileNode) check(c *ctx) {
- if n == nil {
- return
- }
-
- n.PackageClause.check(c)
- for l := n.ImportDeclList; l != nil; l = l.List {
- l.ImportDecl.check(c)
- }
- for l := n.TopLevelDeclList; l != nil; l = l.List {
- switch x := l.TopLevelDecl.(type) {
- case *TypeDeclNode:
- x.check(c)
- case *ConstDeclNode:
- x.check(c)
- case *VarDeclNode:
- x.check(c)
- case *FunctionDeclNode:
- x.check(c)
- case *MethodDeclNode:
- x.check(c)
- default:
- panic(todo("%v: %T %s", x.Position(), x, x.Source(false)))
- }
- }
-}
-
-func (n *MethodDeclNode) check(c *ctx) {
- if n == nil {
- return
- }
-
- n.Receiver.check(c)
- n.Signature.check(c)
-}
-
-func (n *FunctionDeclNode) check(c *ctx) {
- if n == nil {
- return
- }
-
- if c.isBuiltin() {
- switch nm := n.FunctionName.IDENT.Src(); nm {
- case
- "append",
- "cap",
- "close",
- "complex",
- "copy",
- "delete",
- "imag",
- "len",
- "make",
- "new",
- "panic",
- "print",
- "println",
- "real",
- "recover",
-
- // Go 1.21
- "max",
- "min",
- "clear":
-
- n.Signature.t = c.newPredeclaredType(n, Function)
- default:
- panic(todo("%v: %q %s", n.Position(), nm, n.Source(false)))
- }
- return
- }
-
- n.Signature.check(c)
- if n.TypeParameters != nil {
- panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
- }
-}
-
-func (n *SignatureNode) check(c *ctx) Type {
- if n == nil {
- return Invalid
- }
-
- if !n.enter(c, n) {
- return n.Type()
- }
-
- in := n.Parameters.check(c)
- out := n.Result.check(c)
- return n.setType(newTupleType(n.Parameters, []Type{in, out}))
-}
-
-func (n *ResultNode) check(c *ctx) Type {
- if n == nil {
- return Invalid
- }
-
- switch {
- case n.Parameters != nil:
- return n.Parameters.check(c)
- case n.TypeNode != nil:
- return n.TypeNode.check(c)
- default:
- panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
- }
-}
-
-func (n *ParametersNode) check(c *ctx) Type {
- if n == nil {
- return Invalid
- }
-
- r := newTupleType(n, nil)
- for l := n.ParameterDeclList; l != nil; l = l.List {
- r.Types = append(r.Types, l.ParameterDecl.check(c)...)
- }
- return r
-}
-
-func (n *ParameterDeclNode) check(c *ctx) (r []Type) {
- if n == nil {
- return nil
- }
-
- t := n.TypeNode.check(c)
- for l := n.IdentifierList; l != nil; l = l.List {
- r = append(r, t)
- }
- return r
-}
-
-func (n *VarDeclNode) check(c *ctx) {
- if n == nil {
- return
- }
-
- switch x := n.VarSpec.(type) {
- case *VarSpecNode:
- x.check(c)
- default:
- panic(todo("%v: %T %s", n.Position(), x, n.Source(false)))
- }
-}
-
-func (n *VarSpecNode) check(c *ctx) {
- if n == nil {
- return
- }
-
- if c.isBuiltin() {
- switch nm := n.IDENT.Src(); nm {
- case "nil":
- n.TypeNode = c.newPredeclaredType(n, UntypedNil)
- default:
- panic(todo("%v: %q", n.IDENT.Position(), nm))
- }
- return
- }
-
- if n.TypeNode != nil {
- c.err(n, "TODO %v", n.TypeNode.Source(false))
- }
- var e []Expression
- for l := n.ExpressionList; l != nil; l = l.List {
- e = append(e, l.Expression.checkExpr(c))
- }
- switch len(e) {
- default:
- panic(todo("", len(e)))
- c.err(n, "TODO %v", len(e))
- }
-}
-
-func (n *ConstDeclNode) check(c *ctx) {
- if n == nil {
- return
- }
-
- switch x := n.ConstSpec.(type) {
- case *ConstSpecListNode:
- var prev Node
- for l := x; l != nil; l = l.List {
- switch y := l.ConstSpec.(type) {
- case *ConstSpecNode:
- y.check(c, prev)
- if y.Expression != nil || y.TypeNode != nil {
- prev = y
- }
- default:
- panic(todo("%v: %T %s", n.Position(), y, n.Source(false)))
- }
- }
- case *ConstSpecNode:
- x.check(c, nil)
- default:
- panic(todo("%v: %T %s", n.Position(), x, n.Source(false)))
- }
-
-}
-
-func (n *ConstSpecNode) check(c *ctx, prev Node) {
- if n == nil {
- return
- }
-
- if !n.enter(c, n) {
- if n.guard == guardChecking {
- panic(todo("")) // report recursive
- }
- return
- }
-
- defer func() { n.guard = guardChecked }()
-
- if c.isBuiltin() {
- switch n.IDENT.Src() {
- case "true":
- switch x := n.Expression.(type) {
- case *BinaryExpressionNode:
- x.setValue(trueVal)
- x.setType(c.newPredeclaredType(x, UntypedBool))
- default:
- panic(todo("%v: %T %s", n.Position(), x, n.Source(false)))
- }
- case "false":
- switch x := n.Expression.(type) {
- case *BinaryExpressionNode:
- x.setValue(falseVal)
- x.setType(c.newPredeclaredType(x, UntypedBool))
- default:
- panic(todo("%v: %T %s", n.Position(), x, n.Source(false)))
- }
- case "iota":
- switch x := n.Expression.(type) {
- case *BasicLitNode:
- // ok
- default:
- panic(todo("%v: %T %s", n.Position(), x, n.Source(false)))
- }
- default:
- panic(todo("", n.Position(), n.Source(false)))
- }
- return
- }
-
- save := c.iota
- c.iota = n.iota
-
- defer func() { c.iota = save }()
-
- switch {
- case n.Expression != nil:
- n.Expression = n.Expression.checkExpr(c)
- if n.TypeNode == nil {
- n.TypeNode = n.Expression.Type()
- return
- }
-
- t := n.TypeNode.check(c)
- trc("", t)
- panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
- default:
- // var e Expression
- // var pe *Expression
- // switch {
- // case n.Expression != nil:
- // e = n.Expression
- // pe = &n.Expression
- // default:
- // switch x := prev.(type) {
- // case *ConstSpecNode:
- // e = x.Expression.clone()
- // pe = &e
- // default:
- // panic(todo("%v: %T %s", n.Position(), x, n.Source(false)))
- // }
- // }
- // ev, et := e.checkExpr(c, pe)
- // e = *pe
- // if ev.Kind() == constant.Unknown {
- // c.err(e, "%s is not a constant", e.Source(false))
- // n.t = Invalid
- // n.setValue(unknown)
- // return Invalid
- // }
- // switch {
- // case n.t == nil:
- // n.t = et
- // default:
-
- // c.err(n.Expression, "cannot assign %v (type %v) to type %v", ev, et, n.Type())
- // return Invalid
- // } else {
- // n.setValue(convertValue(c, e, ev, n.Type()))
- // }
- // }
- // return n.Type()
- panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
- }
-
-}
-
-func (n *TypeDeclNode) check(c *ctx) {
- if n == nil {
- return
- }
-
- for l := n.TypeSpecList; l != nil; l = l.List {
- switch x := l.TypeSpec.(type) {
- case *TypeDefNode:
- switch {
- case c.isBuiltin():
- x.pkg = c.pkg
- switch nm := x.IDENT.Src(); nm {
- case "bool":
- x.TypeNode = c.newPredeclaredType(x, Bool)
- case "int":
- x.TypeNode = c.newPredeclaredType(x, Int)
- c.cfg.int = x.TypeNode
- case "int8":
- x.TypeNode = c.newPredeclaredType(x, Int8)
- case "int16":
- x.TypeNode = c.newPredeclaredType(x, Int16)
- case "int32":
- x.TypeNode = c.newPredeclaredType(x, Int32)
- case "int64":
- x.TypeNode = c.newPredeclaredType(x, Int64)
- case "uint":
- x.TypeNode = c.newPredeclaredType(x, Uint)
- c.cfg.uint = x.TypeNode
- case "uint8":
- x.TypeNode = c.newPredeclaredType(x, Uint8)
- case "uint16":
- x.TypeNode = c.newPredeclaredType(x, Uint16)
- case "uint32":
- x.TypeNode = c.newPredeclaredType(x, Uint32)
- case "uint64":
- x.TypeNode = c.newPredeclaredType(x, Uint64)
- case "uintptr":
- x.TypeNode = c.newPredeclaredType(x, Uintptr)
- case "string":
- x.TypeNode = c.newPredeclaredType(x, String)
- case "float32":
- x.TypeNode = c.newPredeclaredType(x, Float32)
- case "float64":
- x.TypeNode = c.newPredeclaredType(x, Float64)
- case "complex64":
- x.TypeNode = c.newPredeclaredType(x, Complex64)
- case "complex128":
- x.TypeNode = c.newPredeclaredType(x, Complex128)
- case "comparable":
- x.TypeNode = c.newPredeclaredType(x, Interface)
- case "error":
- x.check(c)
- default:
- if token.IsExported(nm) {
- delete(c.pkg.Scope.nodes, nm)
- return
- }
-
- panic(todo("%v: %T %s", x.Position(), x, x.Source(false)))
- }
- case c.isUnsafe():
- switch nm := x.IDENT.Src(); nm {
- case "ArbitraryType", "IntegerType", "Pointer":
- x.TypeNode.check(c)
- default:
- panic(todo("%v: %T %s", x.Position(), x, x.Source(false)))
- }
- default:
- switch {
- case x.TypeParameters != nil:
- panic(todo("%v: %T %s", x.Position(), x, x.Source(false)))
- default:
- x.check(c)
- }
- }
- case *AliasDeclNode:
- x.check(c)
- default:
- panic(todo("%v: %T %s", x.Position(), x, x.Source(false)))
- }
- }
-}
-
-func (n *AliasDeclNode) check(c *ctx) {
- if n == nil {
- return
- }
-
- n.TypeNode.check(c)
-}
-
-func (n *ImportDeclNode) check(c *ctx) {
- if n == nil {
- return
- }
-
- type result struct {
- spec *ImportSpecNode
- pkg *Package
- err error
- }
- var a []*result
- var wg sync.WaitGroup
- for l := n.ImportSpecList; l != nil; l = l.List {
- r := &result{}
- a = append(a, r)
- wg.Add(1)
- go func(isln *ImportSpecListNode, r *result) {
-
- defer wg.Done()
-
- r.spec = isln.ImportSpec
- r.pkg, r.err = r.spec.check(c)
- r.spec.pkg = r.pkg
- }(l, r)
- }
- wg.Wait()
- fileScope := c.ast.FileScope
- pkgScope := c.pkg.Scope
- for _, v := range a {
- switch x := v.err.(type) {
- case nil:
- // ok
- default:
- panic(todo("%v: %T: %s", v.spec.Position(), x, x))
- }
- if c.pkg.ImportPath == "builtin" && v.spec.ImportPath.Src() == `"cmp"` {
- continue
- }
-
- switch ex := fileScope.declare(v.pkg.Name, v.spec, 0, nil, true); {
- case ex.declTok.IsValid():
- c.err(n, "%s redeclared, previous declaration at %v:", v.pkg.Name.Src(), ex.declTok.Position())
- continue
- }
-
- switch ex := pkgScope.declare(v.pkg.Name, v.spec, 0, nil, true); {
- case ex.declTok.IsValid():
- c.err(n, "%s redeclared, previous declaration at %v:", v.pkg.Name.Src(), ex.declTok.Position())
- continue
- }
- }
-}
-
-func (n *ImportSpecNode) check(c *ctx) (*Package, error) {
- if n == nil {
- return nil, nil
- }
-
- switch {
- case n.PERIOD.IsValid():
- panic(todo("", n.Position(), n.Source(false)))
- case n.PackageName.IsValid():
- //TODO version
- check := c.pkg.typeCheck
- switch check {
- case TypeCheckAll:
- // nop
- default:
- panic(todo("", check))
- }
- return c.cfg.newPackage(c.pkg.FSPath, constant.StringVal(n.ImportPath.Value()), "", nil, false, check, c.pkg.guard)
- default:
- //TODO version
- check := c.pkg.typeCheck
- switch check {
- case TypeCheckAll:
- // nop
- default:
- if c.pkg.ImportPath == "builtin" && n.ImportPath.Src() == `"cmp"` {
- return nil, nil
- }
- }
- return c.cfg.newPackage(c.pkg.FSPath, constant.StringVal(n.ImportPath.Value()), "", nil, false, check, c.pkg.guard)
- }
-}
-
-func (n *PackageClauseNode) check(c *ctx) {
- if n == nil {
- return
- }
-
- nm := n.PackageName.Src()
- if ex := c.pkg.Name; ex.IsValid() && ex.Src() != nm {
- c.err(n.PackageName, "found different packages %q and %q", ex.Src(), nm)
- return
- }
-
- c.pkg.Name = n.PackageName
-}
generated by cgit v1.2.3 (git 2.46.0) at 2025-07-13 02:07:52 +0000