[WIP] Compiler+VM POC

bbq/commons/constants.go

@@ -0,0 +1,34 @@
+/*
+ * Cadence - The resource-oriented smart contract programming language
+ *
+ * Copyright Flow Foundation
+ *
+ * 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
+ *
+ *   http://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.
+ */
+
+package commons
+
+const (
+	InitFunctionName                = "init"
+	TransactionWrapperCompositeName = "transaction"
+	TransactionExecuteFunctionName  = "transaction.execute"
+	TransactionPrepareFunctionName  = "transaction.prepare"
+	LogFunctionName                 = "log"
+	PanicFunctionName               = "panic"
+	GetAccountFunctionName          = "getAccount"
+
+	// Names used by generated constructs
+
+	ProgramInitFunctionName         = "$_init_"
+	TransactionGeneratedParamPrefix = "$_param_"
+)

bbq/commons/handlers.go

@@ -0,0 +1,56 @@
+/*
+ * Cadence - The resource-oriented smart contract programming language
+ *
+ * Copyright Flow Foundation
+ *
+ * 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
+ *
+ *   http://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.
+ */
+
+package commons
+
+import (
+	"github.com/onflow/cadence/ast"
+	"github.com/onflow/cadence/bbq"
+	"github.com/onflow/cadence/bbq/opcode"
+	"github.com/onflow/cadence/common"
+	"github.com/onflow/cadence/sema"
+)
+
+type ImportHandler func(location common.Location) *bbq.Program[opcode.Instruction]
+
+type LocationHandler func(identifiers []ast.Identifier, location common.Location) ([]ResolvedLocation, error)
+
+type ResolvedLocation = sema.ResolvedLocation
+
+func ResolveLocation(
+	locationHandler LocationHandler,
+	identifiers []ast.Identifier,
+	location common.Location,
+) ([]ResolvedLocation, error) {
+
+	// If no location handler is available,
+	// default to resolving to a single location that declares all identifiers
+
+	if locationHandler == nil {
+		return []ResolvedLocation{
+			{
+				Location:    location,
+				Identifiers: identifiers,
+			},
+		}, nil
+	}
+
+	// A location handler is available,
+	// use it to resolve the location / identifiers
+	return locationHandler(identifiers, location)
+}

bbq/commons/utils.go

@@ -0,0 +1,51 @@
+/*
+ * Cadence - The resource-oriented smart contract programming language
+ *
+ * Copyright Flow Foundation
+ *
+ * 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
+ *
+ *   http://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.
+ */
+
+package commons
+
+import (
+	"bytes"
+
+	"github.com/onflow/cadence/common"
+	"github.com/onflow/cadence/interpreter"
+)
+
+func TypeQualifiedName(typeName, functionName string) string {
+	if typeName == "" {
+		return functionName
+	}
+
+	return typeName + "." + functionName
+}
+
+func LocationToBytes(location common.Location) ([]byte, error) {
+	var buf bytes.Buffer
+	enc := interpreter.CBOREncMode.NewStreamEncoder(&buf)
+
+	err := interpreter.EncodeLocation(enc, location)
+	if err != nil {
+		return nil, err
+	}
+
+	err = enc.Flush()
+	if err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}

bbq/compiler/codegen.go

@@ -0,0 +1,88 @@
+/*
+ * Cadence - The resource-oriented smart contract programming language
+ *
+ * Copyright Flow Foundation
+ *
+ * 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
+ *
+ *   http://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.
+ */
+
+package compiler
+
+import (
+	"github.com/onflow/cadence/bbq/opcode"
+	"github.com/onflow/cadence/errors"
+)
+
+type CodeGen[E any] interface {
+	Offset() int
+	SetTarget(code *[]E)
+	Emit(instruction opcode.Instruction)
+	PatchJump(offset int, newTarget uint16)
+}
+
+// ByteCodeGen is a CodeGen implementation that emits bytecode
+type ByteCodeGen struct {
+	target *[]byte
+}
+
+var _ CodeGen[byte] = &ByteCodeGen{}
+
+func (g *ByteCodeGen) Offset() int {
+	return len(*g.target)
+}
+
+func (g *ByteCodeGen) SetTarget(target *[]byte) {
+	g.target = target
+}
+
+func (g *ByteCodeGen) Emit(instruction opcode.Instruction) {
+	instruction.Encode(g.target)
+}
+
+func (g *ByteCodeGen) PatchJump(offset int, newTarget uint16) {
+	opcode.PatchJump(g.target, offset, newTarget)
+}
+
+// InstructionCodeGen is a CodeGen implementation that emits opcode.Instruction
+type InstructionCodeGen struct {
+	target *[]opcode.Instruction
+}
+
+var _ CodeGen[opcode.Instruction] = &InstructionCodeGen{}
+
+func (g *InstructionCodeGen) Offset() int {
+	return len(*g.target)
+}
+
+func (g *InstructionCodeGen) SetTarget(target *[]opcode.Instruction) {
+	g.target = target
+}
+
+func (g *InstructionCodeGen) Emit(instruction opcode.Instruction) {
+	*g.target = append(*g.target, instruction)
+}
+
+func (g *InstructionCodeGen) PatchJump(offset int, newTarget uint16) {
+	switch ins := (*g.target)[offset].(type) {
+	case opcode.InstructionJump:
+		ins.Target = newTarget
+		(*g.target)[offset] = ins
+
+	case opcode.InstructionJumpIfFalse:
+		ins.Target = newTarget
+		(*g.target)[offset] = ins
+
+	default:
+		panic(errors.NewUnreachableError())
+	}
+}