From 521af487434295fe570d5eb584e196651ffdba63 Mon Sep 17 00:00:00 2001 From: chai2010 Date: Tue, 9 Apr 2024 23:03:04 +0800 Subject: [PATCH 1/2] =?UTF-8?q?=E5=B1=80=E9=83=A8=E4=BB=A3=E7=A0=81?= =?UTF-8?q?=E5=AE=8C=E5=96=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- internal/types/expr.go | 10 +- internal/types/operator.go | 185 ++++++++++++++++++++++++++++++++----- 2 files changed, 164 insertions(+), 31 deletions(-) diff --git a/internal/types/expr.go b/internal/types/expr.go index 715ff22d..70639c8f 100644 --- a/internal/types/expr.go +++ b/internal/types/expr.go @@ -100,8 +100,7 @@ func (check *Checker) unary(x *operand, e *ast.UnaryExpr, op token.Token) { return } - if fn := check.tryUnaryOperatorCall(x, e, op); fn != nil { - x.mode = value + if check.tryUnaryOperatorCall(x, e) { return } @@ -781,13 +780,12 @@ func (check *Checker) binary(x *operand, e *ast.BinaryExpr, lhs, rhs ast.Expr, o return } - if isShift(op) { - check.shift(x, &y, e, op) + if check.tryBinaryOperatorCall(x, &y, e) { return } - if fn := check.tryBinaryOperatorCall(x, e, lhs, rhs, op); fn != nil { - x.mode = value + if isShift(op) { + check.shift(x, &y, e, op) return } diff --git a/internal/types/operator.go b/internal/types/operator.go index 7ac956fb..4a2e5855 100644 --- a/internal/types/operator.go +++ b/internal/types/operator.go @@ -132,42 +132,177 @@ func (check *Checker) processTypeOperators() { } } -func (check *Checker) tryUnaryOperatorCall( - x *operand, e *ast.UnaryExpr, - op token.Token, -) *Func { +func (check *Checker) tryUnaryOperatorCall(x *operand, e *ast.UnaryExpr) bool { + if true { + return false // todo(chai): debug + } + assert(x.typ != nil) - var ops *typeOperator - switch typ := x.typ.(type) { - case *Named: - ops = typ.obj.ops - default: - // todo(chai) + var xNamed *Named + if v, ok := x.typ.(*Named); ok { + xNamed = v } - if ops == nil { - return nil + if xNamed == nil || xNamed.obj == nil || xNamed.obj.ops == nil { + return false } - switch op { + var fn *Func + switch e.Op { case token.ADD: - return ops.Unary_ADD + fn = xNamed.obj.ops.Unary_ADD case token.SUB: - return ops.Unary_SUB + fn = xNamed.obj.ops.Unary_SUB case token.XOR: - return ops.Unary_XOR + fn = xNamed.obj.ops.Unary_XOR case token.NOT: - return ops.Unary_NOT + fn = xNamed.obj.ops.Unary_NOT + } + if fn == nil { + return false } - unreachable() - return nil + err := check.tryUnaryOpFunc(fn, x, e) + if err == nil { + return false + } + + x.mode = value + x.typ = fn.typ.(*Signature).results.vars[0].typ + x.expr = &ast.CallExpr{ + Fun: &ast.SelectorExpr{ + X: &ast.Ident{Name: fn.pkg.path}, + Sel: &ast.Ident{Name: fn.pkg.name}, + }, + Args: []ast.Expr{e.X}, + } + + check.hasCallOrRecv = true + return true } -func (check *Checker) tryBinaryOperatorCall( - x *operand, e *ast.BinaryExpr, - lhs, rhs ast.Expr, - op token.Token, -) *Func { - return nil // todo(chai) +func (check *Checker) tryBinaryOperatorCall(x, y *operand, e *ast.BinaryExpr) bool { + if true { + return false // todo(chai): debug + } + + var xNamed, yNamed *Named + if v, ok := x.typ.(*Named); ok { + xNamed = v + } + if v, ok := y.typ.(*Named); ok { + yNamed = v + } + + // 至少有1个是自定义类型 + if xNamed == nil && yNamed == nil { + return false + } + + // 根据左右顺序匹配 + xFuncs := check.getBinOpFuncs(xNamed, e.Op) + yFuncs := check.getBinOpFuncs(yNamed, e.Op) + + var fnMached *Func + if fnMached == nil { + for _, fn := range xFuncs { + if err := check.tryBinOpFunc(fn, x, y, e); err == nil { + fnMached = fn + break + } + } + } + if fnMached == nil { + for _, fn := range yFuncs { + if err := check.tryBinOpFunc(fn, x, y, e); err == nil { + fnMached = fn + break + } + } + } + if fnMached == nil { + return false + } + + x.mode = value + x.typ = fnMached.typ.(*Signature).results.vars[0].typ + x.expr = &ast.CallExpr{ + Fun: &ast.SelectorExpr{ + X: &ast.Ident{Name: fnMached.pkg.path}, + Sel: &ast.Ident{Name: fnMached.pkg.name}, + }, + Args: []ast.Expr{e.X}, + } + + check.hasCallOrRecv = true + return true +} + +func (check *Checker) tryUnaryOpFunc(fn *Func, x *operand, e *ast.UnaryExpr) (err error) { + assert(fn != nil) + + firstErrBak := check.firstErr + check.firstErr = nil + + defer func() { check.firstErr = firstErrBak }() + + defer check.handleBailout(&err) + + check.rawExpr(x, e.X, nil) + + assert(fn.typ != nil) + sig, _ := fn.typ.(*Signature) + assert(sig != nil) + assert(sig.recv == nil) + assert(sig.params.Len() == 1) + assert(sig.results.Len() == 1) + + // 检查参数是否匹配 + check.argument(sig, 0, x, token.NoPos, "") + return +} + +func (check *Checker) tryBinOpFunc(fn *Func, x, y *operand, e *ast.BinaryExpr) (err error) { + firstErrBak := check.firstErr + check.firstErr = nil + + defer func() { check.firstErr = firstErrBak }() + + defer check.handleBailout(&err) + + check.rawExpr(x, e.X, nil) + check.rawExpr(y, e.Y, nil) + + assert(fn.typ != nil) + sig, _ := fn.typ.(*Signature) + assert(sig != nil) + assert(sig.recv == nil) + assert(sig.params.Len() == 2) + assert(sig.results.Len() == 1) + + // 检查参数是否匹配 + check.argument(sig, 0, x, token.NoPos, "") + check.argument(sig, 1, y, token.NoPos, "") + return +} + +func (check *Checker) getBinOpFuncs(x *Named, op token.Token) []*Func { + if x == nil { + return nil + } + if typ := x.obj; typ != nil && typ.ops != nil { + switch op { + case token.ADD: + return typ.ops.ADD + case token.SUB: + return typ.ops.ADD + case token.MUL: + return typ.ops.ADD + case token.QUO: + return typ.ops.ADD + case token.REM: + return typ.ops.ADD + } + } + return nil } From 9862f39c8035066c0d538ebd47577fe80d355293 Mon Sep 17 00:00:00 2001 From: chai2010 Date: Wed, 10 Apr 2024 08:26:46 +0800 Subject: [PATCH 2/2] =?UTF-8?q?=E5=B1=80=E9=83=A8=E4=BB=A3=E7=A0=81?= =?UTF-8?q?=E5=AE=8C=E5=96=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- internal/types/call.go | 13 ++++++++++++- internal/types/operator.go | 4 ++-- 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/internal/types/call.go b/internal/types/call.go index 82b23cef..4d8ad928 100644 --- a/internal/types/call.go +++ b/internal/types/call.go @@ -315,7 +315,18 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr) { // can only appear in qualified identifiers which are mapped to // selector expressions. if ident, ok := e.X.(*ast.Ident); ok { - obj := check.lookup(ident.Name) + var obj Object + if ident.Name[0] == '#' { + // 内部: 根据包路径查询 + for _, pkg := range check.pkg.imports { + if pkg.path == ident.Name[1:] { + // todo(chai) + } + } + } else { + obj = check.lookup(ident.Name) + } + if pname, _ := obj.(*PkgName); pname != nil { assert(pname.pkg == check.pkg) check.recordUse(ident, pname) diff --git a/internal/types/operator.go b/internal/types/operator.go index 4a2e5855..e597abd8 100644 --- a/internal/types/operator.go +++ b/internal/types/operator.go @@ -171,7 +171,7 @@ func (check *Checker) tryUnaryOperatorCall(x *operand, e *ast.UnaryExpr) bool { x.typ = fn.typ.(*Signature).results.vars[0].typ x.expr = &ast.CallExpr{ Fun: &ast.SelectorExpr{ - X: &ast.Ident{Name: fn.pkg.path}, + X: &ast.Ident{Name: "#" + fn.pkg.path}, Sel: &ast.Ident{Name: fn.pkg.name}, }, Args: []ast.Expr{e.X}, @@ -228,7 +228,7 @@ func (check *Checker) tryBinaryOperatorCall(x, y *operand, e *ast.BinaryExpr) bo x.typ = fnMached.typ.(*Signature).results.vars[0].typ x.expr = &ast.CallExpr{ Fun: &ast.SelectorExpr{ - X: &ast.Ident{Name: fnMached.pkg.path}, + X: &ast.Ident{Name: "#" + fnMached.pkg.path}, Sel: &ast.Ident{Name: fnMached.pkg.name}, }, Args: []ast.Expr{e.X},