package compiler import ( "fmt" "go/ast" "go/constant" "go/types" "github.com/nspcc-dev/neo-go/pkg/core/interop/runtime" "github.com/nspcc-dev/neo-go/pkg/smartcontract/binding" "github.com/nspcc-dev/neo-go/pkg/smartcontract/callflag" "github.com/nspcc-dev/neo-go/pkg/util" "github.com/nspcc-dev/neo-go/pkg/vm/emit" "github.com/nspcc-dev/neo-go/pkg/vm/opcode" "github.com/nspcc-dev/neo-go/pkg/vm/stackitem" ) // inlineCall inlines call of n for function represented by f. // Call `f(a,b)` for definition `func f(x,y int)` is translated to block: // // { // x := a // y := b // <inline body of f directly> // } func (c *codegen) inlineCall(f *funcScope, n *ast.CallExpr) { offSz := len(c.inlineContext) c.inlineContext = append(c.inlineContext, inlineContextSingle{ labelOffset: len(c.labelList), returnLabel: c.newLabel(), }) defer func() { c.labelList = c.labelList[:c.inlineContext[offSz].labelOffset] c.inlineContext = c.inlineContext[:offSz] }() pkg := c.packageCache[f.pkg.Path()] sig := c.typeOf(n.Fun).(*types.Signature) hasVarArgs := !n.Ellipsis.IsValid() eventParams := c.processStdlibCall(f, n.Args, !hasVarArgs) // When inlined call is used during global initialization // there is no func scope, thus this if. if c.scope == nil { c.scope = &funcScope{} c.scope.vars.newScope() defer func() { if cnt := c.scope.vars.localsCnt; cnt > c.globalInlineCount { c.globalInlineCount = cnt } c.scope = nil }() } // Arguments need to be walked with the current scope, // while stored in the new. oldScope := c.scope.vars.locals c.scope.vars.newScope() newScope := make([]map[string]varInfo, len(c.scope.vars.locals)) copy(newScope, c.scope.vars.locals) defer c.scope.vars.dropScope() if f.decl.Recv != nil { c.scope.vars.locals = newScope name := f.decl.Recv.List[0].Names[0].Name c.scope.vars.addAlias(name, -1, unspecifiedVarIndex, &varContext{ importMap: c.importMap, expr: f.selector, scope: oldScope, }) } needPack := sig.Variadic() && hasVarArgs for i := range n.Args { c.scope.vars.locals = oldScope // true if normal arg or var arg is `slice...` needStore := i < sig.Params().Len()-1 || !sig.Variadic() || !hasVarArgs if !needStore { break } name := sig.Params().At(i).Name() if !c.hasCalls(n.Args[i]) { // If argument contains no calls, we save context and traverse the expression // when argument is emitted. c.scope.vars.locals = newScope c.scope.vars.addAlias(name, -1, unspecifiedVarIndex, &varContext{ importMap: c.importMap, expr: n.Args[i], scope: oldScope, }) continue } ast.Walk(c, n.Args[i]) c.scope.vars.locals = newScope c.scope.newLocal(name) c.emitStoreVar("", name) } if needPack { // traverse variadic args and pack them // if they are provided directly i.e. without `...` c.scope.vars.locals = oldScope for i := sig.Params().Len() - 1; i < len(n.Args); i++ { ast.Walk(c, n.Args[i]) // In case of runtime.Notify, its arguments need to be converted to proper type. // i's initial value is 1 (variadic args start). if eventParams != nil && eventParams[i-1] != nil { c.emitConvert(*eventParams[i-1]) } } c.scope.vars.locals = newScope c.packVarArgs(n, sig) name := sig.Params().At(sig.Params().Len() - 1).Name() c.scope.newLocal(name) c.emitStoreVar("", name) } c.pkgInfoInline = append(c.pkgInfoInline, pkg) oldMap := c.importMap oldDefers := c.scope.deferStack c.scope.deferStack = nil c.fillImportMap(f.file, pkg) ast.Inspect(f.decl, c.scope.analyzeVoidCalls) ast.Walk(c, f.decl.Body) c.setLabel(c.inlineContext[offSz].returnLabel) if c.scope.voidCalls[n] { for i := 0; i < f.decl.Type.Results.NumFields(); i++ { emit.Opcodes(c.prog.BinWriter, opcode.DROP) } } c.processDefers() c.scope.deferStack = oldDefers c.importMap = oldMap c.pkgInfoInline = c.pkgInfoInline[:len(c.pkgInfoInline)-1] } func (c *codegen) processStdlibCall(f *funcScope, args []ast.Expr, hasEllipsis bool) []*stackitem.Type { if f == nil { return nil } var eventParams []*stackitem.Type if f.pkg.Path() == interopPrefix+"/runtime" && (f.name == "Notify" || f.name == "Log") { eventParams = c.processNotify(f, args, hasEllipsis) } if f.pkg.Path() == interopPrefix+"/contract" && f.name == "Call" { c.processContractCall(f, args) } return eventParams } // processNotify checks whether notification emitting rules are met and returns expected // notification signature if found. func (c *codegen) processNotify(f *funcScope, args []ast.Expr, hasEllipsis bool) []*stackitem.Type { if c.scope != nil && c.isVerifyFunc(c.scope.decl) && c.scope.pkg == c.mainPkg.Types && (c.buildInfo.options == nil || !c.buildInfo.options.NoEventsCheck) { c.prog.Err = fmt.Errorf("runtime.%s is not allowed in `Verify`", f.name) return nil } if f.name == "Log" { return nil } // Sometimes event name is stored in a var. Or sometimes event args are provided // via ellipses (`slice...`). // Skip in this case. Also, don't enforce runtime.Notify parameters conversion. tv := c.typeAndValueOf(args[0]) if tv.Value == nil || hasEllipsis { return nil } params := make([]DebugParam, 0, len(args[1:])) vParams := make([]*stackitem.Type, 0, len(args[1:])) // extMap holds the extended parameter types used for the given event call. // It will be unified with the common extMap later during bindings config // generation. extMap := make(map[string]binding.ExtendedType) for _, p := range args[1:] { st, vt, over, extT := c.scAndVMTypeFromExpr(p, extMap) params = append(params, DebugParam{ Name: "", // Parameter name will be filled in several lines below if the corresponding event exists in the buildinfo.options. Type: vt.String(), RealType: over, ExtendedType: extT, TypeSC: st, }) vParams = append(vParams, &vt) } name := constant.StringVal(tv.Value) if len(name) > runtime.MaxEventNameLen { c.prog.Err = fmt.Errorf("event name '%s' should be less than %d", name, runtime.MaxEventNameLen) return nil } var eventFound bool if c.buildInfo.options != nil && c.buildInfo.options.ContractEvents != nil { for _, e := range c.buildInfo.options.ContractEvents { if e.Name == name && len(e.Parameters) == len(vParams) { eventFound = true for i, scParam := range e.Parameters { params[i].Name = scParam.Name if !c.buildInfo.options.NoEventsCheck { expectedType := scParam.Type.ConvertToStackitemType() // No need to cast if the desired type is unknown. if expectedType == stackitem.AnyT || // Do not cast if desired type is Interop, the actual type is likely to be Any, leave the resolving to runtime.Notify. expectedType == stackitem.InteropT || // No need to cast if actual parameter type matches the desired one. *vParams[i] == expectedType || // expectedType doesn't contain Buffer anyway, but if actual variable type is Buffer, // then runtime.Notify will convert it to ByteArray automatically, thus no need to emit conversion code. (*vParams[i] == stackitem.BufferT && expectedType == stackitem.ByteArrayT) { vParams[i] = nil } else { // For other cases the conversion code will be emitted using vParams... vParams[i] = &expectedType // ...thus, update emitted notification info in advance. params[i].Type = scParam.Type.String() params[i].TypeSC = scParam.Type } } } } } } c.emittedEvents[name] = append(c.emittedEvents[name], EmittedEventInfo{ ExtTypes: extMap, Params: params, }) // Do not enforce perfect expected/actual events match on this step, the final // check wil be performed after compilation if --no-events option is off. if eventFound && !c.buildInfo.options.NoEventsCheck { return vParams } return nil } func (c *codegen) processContractCall(f *funcScope, args []ast.Expr) { var u util.Uint160 // For stdlib calls it is `interop.Hash160(constHash)` // so we can determine hash at compile-time. ce, ok := args[0].(*ast.CallExpr) if ok && len(ce.Args) == 1 { // Ensure this is a type conversion, not a simple invoke. se, ok := ce.Fun.(*ast.SelectorExpr) if ok { name, _ := c.getFuncNameFromSelector(se) if _, ok := c.funcs[name]; !ok { value := c.typeAndValueOf(ce.Args[0]).Value if value != nil { s := constant.StringVal(value) copy(u[:], s) // constant must be big-endian } } } } value := c.typeAndValueOf(args[1]).Value if value == nil { return } method := constant.StringVal(value) value = c.typeAndValueOf(args[2]).Value if value == nil { return } flag, _ := constant.Uint64Val(value) c.appendInvokedContract(u, method, flag) } func (c *codegen) appendInvokedContract(u util.Uint160, method string, flag uint64) { currLst := c.invokedContracts[u] for _, m := range currLst { if m == method { return } } if flag&uint64(callflag.WriteStates|callflag.AllowNotify) != 0 { c.invokedContracts[u] = append(currLst, method) } } // hasCalls returns true if expression contains any calls. // We uses this as a rough heuristic to determine if expression calculation // has any side-effects. func (c *codegen) hasCalls(expr ast.Expr) bool { var has bool ast.Inspect(expr, func(n ast.Node) bool { ce, ok := n.(*ast.CallExpr) if !has && ok { isFunc := true fun, ok := ce.Fun.(*ast.Ident) if ok { _, isFunc = c.getFuncFromIdent(fun) } else { var sel *ast.SelectorExpr sel, ok = ce.Fun.(*ast.SelectorExpr) if ok { name, _ := c.getFuncNameFromSelector(sel) _, isFunc = c.funcs[name] fun = sel.Sel } } has = isFunc || fun.Obj != nil && (fun.Obj.Kind == ast.Var || fun.Obj.Kind == ast.Fun) } return !has }) return has }