diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 9929240d55..c778cde165 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -39,18 +39,12 @@ jobs:
go-version: ${{ env.GO_VERSION }}
cache: true
- - name: Install Flow CLI
- run: sh -ci "$(curl -fsSL https://raw.githubusercontent.com/onflow/flow-cli/master/install.sh)"
-
- name: Build
run: make -j8 build
- name: Test
run: make ci
- - name: Cadence Testing Framework
- run: cd stdlib/contracts && flow test --cover --covercode="contracts" crypto_test.cdc
-
- name: Upload coverage report
uses: codecov/codecov-action@v2
with:
diff --git a/.github/workflows/compat.yaml b/.github/workflows/compat.yaml
new file mode 100644
index 0000000000..ec22c71cf0
--- /dev/null
+++ b/.github/workflows/compat.yaml
@@ -0,0 +1,24 @@
+name: Source Compatibility Suite
+on:
+ schedule:
+ - cron: '0 12 * * *'
+ workflow_dispatch:
+ inputs:
+
+jobs:
+ source-compat:
+ runs-on: ubuntu-latest
+ steps:
+ - name: Clone
+ uses: actions/checkout@v4
+ - name: Setup Python
+ uses: actions/setup-python@v5
+ with:
+ python-version: '3.12'
+ cache: 'pip'
+ - name: Install dependencies
+ working-directory: compat
+ run: pip3 install -r requirements.txt
+ - name: Run
+ working-directory: compat
+ run: "python3 main.py"
diff --git a/.github/workflows/compat.yaml.disabled b/.github/workflows/compat.yaml.disabled
deleted file mode 100644
index 779ab60b88..0000000000
--- a/.github/workflows/compat.yaml.disabled
+++ /dev/null
@@ -1,34 +0,0 @@
-name: Source Compatibility Suite
-on:
- schedule:
- - cron: '0 12 * * *'
- workflow_dispatch:
- inputs:
- goTestRef:
-
-
-jobs:
- source-compat:
- runs-on: ubuntu-20.04
- steps:
- - uses: actions/checkout@v2
- with:
- fetch-depth: 0
- - uses: actions/setup-go@v2
- with:
- go-version: '1.18.x'
- - uses: actions/setup-python@v2
- with:
- python-version: '3.x'
- - uses: actions/cache@v1
- with:
- path: ~/go/pkg/mod
- key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
- restore-keys: |
- ${{ runner.os }}-go-
- - name: Install dependencies
- working-directory: compat
- run: pip3 install -r requirements.txt
- - name: Check
- working-directory: compat
- run: "python3 main.py --format=pretty --check --go-test --go-test-ref=${{ github.event.inputs.goTestRef }}"
diff --git a/.github/workflows/compatibility-check-template.yml b/.github/workflows/compatibility-check-template.yml
index fc6845f3a5..3a6b1c1130 100644
--- a/.github/workflows/compatibility-check-template.yml
+++ b/.github/workflows/compatibility-check-template.yml
@@ -88,7 +88,7 @@ jobs:
run: |
GOPROXY=direct go mod edit -replace github.com/onflow/cadence=github.com/${{ inputs.repo }}@${{ inputs.current-branch }}
go mod tidy
- go run ./cmd/check_contracts/main.go ../../tmp/contracts.csv ../../tmp/output-new.txt
+ go run ./cmd/check_contracts/main.go flow-${{ inputs.chain }} ../../tmp/contracts.csv ../../tmp/output-new.txt
# Check contracts using base branch
@@ -97,7 +97,7 @@ jobs:
run: |
GOPROXY=direct go mod edit -replace github.com/onflow/cadence=github.com/${{ inputs.repo }}@`git rev-parse origin/${{ inputs.base-branch }}`
go mod tidy
- go run ./cmd/check_contracts/main.go ../../tmp/contracts.csv ../../tmp/output-old.txt
+ go run ./cmd/check_contracts/main.go flow-${{ inputs.chain }} ../../tmp/contracts.csv ../../tmp/output-old.txt
# Upload checking results for later use
diff --git a/Makefile b/Makefile
index e0914ca4e1..16b7bd328f 100644
--- a/Makefile
+++ b/Makefile
@@ -45,7 +45,7 @@ build: build-tools ./cmd/parse/parse ./cmd/parse/parse.wasm ./cmd/check/check ./
go build -o $@ ./cmd/main
.PHONY: build-tools
-build-tools: build-analysis build-get-contracts
+build-tools: build-analysis build-get-contracts build-compatibility-check
.PHONY: build-analysis
build-analysis:
@@ -55,19 +55,32 @@ build-analysis:
build-get-contracts:
(cd ./tools/get-contracts && go build .)
+.PHONY: build-compatibility-check
+build-compatibility-check:
+ (cd ./tools/compatibility-check && go build .)
+
.PHONY: ci
ci:
# test all packages
go test -coverprofile=coverage.txt -covermode=atomic -parallel 8 -race -coverpkg $(COVERPKGS) ./...
# run interpreter smoke tests. results from run above are reused, so no tests runs are duplicated
- go test -count=5 ./tests/interpreter/... -runSmokeTests=true -validateAtree=false
+ go test -count=5 ./interpreter/... -runSmokeTests=true -validateAtree=false
# remove coverage of empty functions from report
sed -i -e 's/^.* 0 0$$//' coverage.txt
.PHONY: test
-test:
- # test all packages
- go test -parallel 8 ./...
+test: test-all-packages test-tools
+
+.PHONY: test-all-packages
+test-all-packages:
+ (go test -parallel 8 ./...)
+
+.PHONY: test-tools
+test-tools:
+ (cd ./tools/analysis && go test -parallel 8 ./)
+ (cd ./tools/compatibility-check && go test -parallel 8 ./)
+ (cd ./tools/constructorcheck && go test -parallel 8 ./)
+ (cd ./tools/maprange && go test -parallel 8 ./)
.PHONY: lint-github-actions
lint-github-actions: build-linter
diff --git a/ast/inspector_test.go b/ast/inspector_test.go
index 17979ef95f..5b1ee8c0c8 100644
--- a/ast/inspector_test.go
+++ b/ast/inspector_test.go
@@ -25,7 +25,6 @@ import (
"github.com/onflow/cadence/ast"
"github.com/onflow/cadence/parser"
- "github.com/onflow/cadence/tests/examples"
)
// TestInspector_Elements compares Inspector against Inspect.
@@ -33,9 +32,30 @@ func TestInspector_Elements(t *testing.T) {
t.Parallel()
+ const code = `
+ access(all) contract interface FungibleToken {
+
+ access(all) resource interface Provider {
+ access(all) fun withdraw(amount: Int): @Vault
+ }
+
+ access(all) resource interface Receiver {
+ access(all) fun deposit(vault: @Vault)
+ }
+
+ access(all) resource interface Vault: Provider, Receiver {
+ access(all) balance: Int
+ }
+
+ access(all) fun absorb(vault: @Vault)
+
+ access(all) fun sprout(balance: Int): @Vault
+ }
+ `
+
program, err := parser.ParseProgram(
nil,
- []byte(examples.FungibleTokenContractInterface),
+ []byte(code),
parser.Config{},
)
require.NoError(t, err)
diff --git a/cmd/cmd.go b/cmd/cmd.go
index a267e30a27..b7f11e59d3 100644
--- a/cmd/cmd.go
+++ b/cmd/cmd.go
@@ -97,13 +97,6 @@ func DefaultCheckerConfig(
importedLocation common.Location,
_ ast.Range,
) (sema.Import, error) {
- if importedLocation == stdlib.CryptoCheckerLocation {
- cryptoChecker := stdlib.CryptoChecker()
- return sema.ElaborationImport{
- Elaboration: cryptoChecker.Elaboration,
- }, nil
- }
-
stringLocation, ok := importedLocation.(common.StringLocation)
if !ok {
return nil, &sema.CheckerError{
@@ -126,7 +119,6 @@ func DefaultCheckerConfig(
Elaboration: importedChecker.Elaboration,
}, nil
},
- AttachmentsEnabled: true,
}
}
diff --git a/cmd/info/main.go b/cmd/info/main.go
index 5f737ba99c..7ca71664cc 100644
--- a/cmd/info/main.go
+++ b/cmd/info/main.go
@@ -31,7 +31,7 @@ import (
"github.com/onflow/cadence/parser"
"github.com/onflow/cadence/sema"
"github.com/onflow/cadence/stdlib"
- "github.com/onflow/cadence/tests/checker"
+ "github.com/onflow/cadence/test_utils/sema_utils"
)
type command struct {
@@ -80,7 +80,7 @@ var commands = map[string]command{
func dumpBuiltinTypes() {
- allBaseSemaTypes := checker.AllBaseSemaTypes()
+ allBaseSemaTypes := sema_utils.AllBaseSemaTypes()
types := make([]sema.Type, 0, len(allBaseSemaTypes))
@@ -239,7 +239,7 @@ func dumpBuiltinValues() {
ty sema.Type
}
- allBaseSemaValueTypes := checker.AllBaseSemaValueTypes()
+ allBaseSemaValueTypes := sema_utils.AllBaseSemaValueTypes()
standardLibraryValues := stdlib.DefaultScriptStandardLibraryValues(nil)
valueTypes := make([]valueType, 0, len(allBaseSemaValueTypes)+len(standardLibraryValues))
diff --git a/compat/main.py b/compat/main.py
index 1da0c95d21..e767937bba 100644
--- a/compat/main.py
+++ b/compat/main.py
@@ -1,43 +1,23 @@
from __future__ import annotations
-import dataclasses
-import html
-import json
import logging
import os
-import re
import shlex
import shutil
+import stat
import subprocess
-import sys
-import textwrap
-from collections import defaultdict
from contextlib import contextmanager
from dataclasses import dataclass, field
-from enum import Enum, unique
from pathlib import Path
-from typing import List, Optional, Collection, Dict, IO, Any
-from typing_extensions import Protocol, Literal
+from typing import List, Optional, Collection, Dict
import click as click
import coloredlogs
-import tabulate
import yaml
-from click.utils import LazyFile
from dacite import from_dict
SUITE_PATH = Path("suite").resolve()
-CMD_PATH = Path("../runtime/cmd").resolve()
-PARSER_PATH = Path("parse").resolve()
-CHECKER_PATH = Path("check").resolve()
-
-ansi_escape_pattern = re.compile(r'\x1b[^m]*m')
-
-
-class Openable(Protocol):
- def open(self) -> IO:
- pass
-
+CLI_PATH = SUITE_PATH / "flow-cli" / "cmd" / "flow"
@contextmanager
def cwd(path):
@@ -48,131 +28,79 @@ def cwd(path):
finally:
os.chdir(oldpwd)
+def cadence_replacement(cadence_version: Optional[str]) -> str:
+ if cadence_version:
+ return f'github.com/onflow/cadence@{cadence_version}'
+ # default: point to local cadence repo
+ return shlex.quote(Path.cwd().parent.absolute().resolve().as_posix())
+
+def flowgo_replacement(flowgo_version: Optional[str]) -> str:
+ if flowgo_version:
+ return f'github.com/onflow/flow-go@{flowgo_version}'
+ # default: use the newest version of flow-go available
+ return 'github.com/onflow/flow-go@latest'
+
+def build_cli(
+ cadence_version: Optional[str],
+ flowgo_version: Optional[str]
+):
+ logger.info("Building CLI ...")
+
+ with cwd(SUITE_PATH):
+ working_dir = SUITE_PATH / "flow-cli"
+ Git.clone("https://github.com/onflow/flow-cli.git", "master", working_dir)
+ with cwd(working_dir):
+ Go.replace_dependencies(
+ cadence_version=cadence_version,
+ flowgo_version=flowgo_version
+ )
+ logger.info("Compiling CLI binary")
+ subprocess.run(
+ ["make", "binary"],
+ check=True
+ )
-@dataclass
-class File:
- path: str
- prepare: Optional[str]
- member_account_access: List[str] = field(default_factory=list)
-
- def rewrite(self, path: Path):
- if not isinstance(self.prepare, str):
- return
-
- logger.info(f"Preparing {path}")
-
- source: str
- with path.open(mode="r") as f:
- source = f.read()
-
- def replace(pattern, replacement):
- nonlocal source
- source = re.sub(pattern, replacement, source)
-
- variables = {"replace": replace}
- with cwd(str(path.parent.absolute())):
- exec(self.prepare, variables)
-
- with path.open(mode="w") as f:
- f.write(source)
-
- @classmethod
- def parse(cls, path: Path, use_json: bool, bench: bool) -> (bool, Optional):
- return cls._run(PARSER_PATH, "Parsing", path, use_json, bench)
-
- def check(self, path: Path, use_json: bool, bench: bool) -> (bool, Optional):
- extra_args = [
- f"-memberAccountAccess=S.{path}:S.{(path.parent / Path(other_path)).resolve()}"
- for other_path in self.member_account_access
- ]
- return self._run(CHECKER_PATH, "Checking", path, use_json, bench, extra_args)
-
- @staticmethod
- def _run(
- tool_path: Path,
- verb: str,
- path: Path,
- use_json: bool,
- bench: bool,
- extra_args: List[str] = None
- ) -> (bool, Optional):
- logger.info(f"{verb} {path}")
- json_args = ["-json"] if use_json else []
- bench_args = ["-bench"] if bench else []
- args = json_args + bench_args + (extra_args or [])
-
- completed_process = subprocess.run(
- [tool_path, *args, path],
- cwd=str(path.parent),
- capture_output=use_json
- )
- result = None
- if use_json:
- result = json.loads(completed_process.stdout)
-
- if completed_process.returncode != 0:
- logger.error(f"{verb} failed: {path}")
- return False, result
-
- return True, result
-
+ logger.info("Built CLI")
@dataclass
class GoTest:
path: str
command: str
- def run(self, working_dir: Path, prepare: bool, go_test_ref: Optional[str]) -> bool:
- if go_test_ref:
- replacement = f'github.com/onflow/cadence@{go_test_ref}'
- else:
- replacement = shlex.quote(str(Path.cwd().parent.absolute()))
+ def run(
+ self,
+ working_dir: Path,
+ prepare: bool,
+ cadence_version: Optional[str],
+ flowgo_version: Optional[str]
+ ) -> bool:
with cwd(working_dir / self.path):
if prepare:
- subprocess.run([
- "go", "mod", "edit", "-replace", f'github.com/onflow/cadence={replacement}',
- ])
- subprocess.run([
- "go", "get", "-t", ".",
- ])
-
- result = subprocess.run(shlex.split(self.command))
- return result.returncode == 0
-
-
-@dataclass
-class BenchmarkResult:
- iterations: int
- time: int
-
-
-@dataclass
-class ParseResult:
- error: Optional[Any] = field(default=None)
- bench: Optional[BenchmarkResult] = field(default=None)
-
- @classmethod
- def from_dict(cls, data: Dict):
- return from_dict(data_class=cls, data=data)
+ Go.replace_dependencies(cadence_version, flowgo_version)
+ result = subprocess.run(self.command, shell=True)
+ return result.returncode == 0
@dataclass
-class CheckResult:
- error: Optional[Any] = field(default=None)
- bench: Optional[BenchmarkResult] = field(default=None)
-
- @classmethod
- def from_dict(cls, data: Dict):
- return from_dict(data_class=cls, data=data)
+class CadenceTest:
+ path: str
+ command: str
+ def run(
+ self,
+ working_dir: Path,
+ prepare: bool,
+ cadence_version: Optional[str],
+ flowgo_version: Optional[str]
+ ) -> bool:
-@dataclass
-class Result:
- path: str
- parse_result: ParseResult
- check_result: Optional[CheckResult] = field(default=None)
+ env = os.environ.copy()
+ env["PATH"] = f"{shlex.quote(str(CLI_PATH))}:{env['PATH']}"
+ with cwd(working_dir / self.path):
+ result = subprocess.run(self.command, shell=True, env=env)
+ return result.returncode == 0
def load_index(path: Path) -> List[str]:
logger.info(f"Loading suite index from {path} ...")
@@ -184,8 +112,8 @@ class Description:
description: str
url: str
branch: str
- files: List[File] = field(default_factory=list)
go_tests: List[GoTest] = field(default_factory=list)
+ cadence_tests: List[CadenceTest] = field(default_factory=list)
@staticmethod
def load(name: str) -> Description:
@@ -198,473 +126,105 @@ def load(name: str) -> Description:
def from_dict(cls, data: Dict):
return from_dict(data_class=cls, data=data)
- def _clone(self, working_dir: Path):
- if working_dir.exists():
- shutil.rmtree(working_dir)
-
- logger.info(f"Cloning {self.url} ({self.branch})")
-
- Git.clone(self.url, self.branch, working_dir)
-
def run(
self,
name: str,
prepare: bool,
- use_json: bool,
- bench: bool,
- check: bool,
go_test: bool,
- go_test_ref: Optional[str],
- ) -> (bool, List[Result]):
+ cadence_test: bool,
+ cadence_version: Optional[str],
+ flowgo_version: Optional[str],
+ ) -> (bool):
+
+ logger.info(f"Running tests for {name} ...")
working_dir = SUITE_PATH / name
if prepare:
- self._clone(working_dir)
-
- results: List[Result] = []
- check_succeeded = True
- if check:
- check_succeeded, results = self.check(working_dir, prepare=prepare, use_json=use_json, bench=bench)
+ Git.clone(self.url, self.branch, working_dir)
go_tests_succeeded = True
if go_test:
for test in self.go_tests:
- if not test.run(working_dir, prepare=prepare, go_test_ref=go_test_ref):
+ if not test.run(
+ working_dir,
+ prepare=prepare,
+ cadence_version=cadence_version,
+ flowgo_version=flowgo_version
+ ):
go_tests_succeeded = False
- succeeded = check_succeeded and go_tests_succeeded
+ cadence_tests_succeeded = True
+ if cadence_test:
+ for test in self.cadence_tests:
+ if not test.run(
+ working_dir,
+ prepare=prepare,
+ cadence_version=cadence_version,
+ flowgo_version=flowgo_version
+ ):
+ cadence_tests_succeeded = False
- return succeeded, results
+ return go_tests_succeeded and cadence_tests_succeeded
- def check(self, working_dir: Path, prepare: bool, use_json: bool, bench: bool) -> (bool, List[Result]):
+class Go:
- run_succeeded = True
-
- results: List[Result] = []
-
- for file in self.files:
- path = working_dir.joinpath(file.path)
+ @staticmethod
+ def mod_replace(original: str, replacement: str):
+ subprocess.run(
+ ["go", "mod", "edit", "-replace", f'{original}={replacement}'],
+ check=True
+ )
- if prepare:
- file.rewrite(path)
+ @staticmethod
+ def mod_tidy():
+ subprocess.run(
+ ["go", "mod", "tidy"],
+ check=True
+ )
- parse_succeeded, parse_results = \
- File.parse(path, use_json=use_json, bench=bench)
- result = Result(
- path=str(path),
- parse_result=ParseResult.from_dict(parse_results[0]) if parse_results else None
- )
- if not parse_succeeded:
- run_succeeded = False
- if use_json:
- results.append(result)
- continue
+ @staticmethod
+ def replace_dependencies(
+ cadence_version: Optional[str],
+ flowgo_version: Optional[str]
+ ):
+ logger.info("Editing dependencies")
+ Go.mod_replace("github.com/onflow/cadence", cadence_replacement(cadence_version))
+ Go.mod_replace("github.com/onflow/flow-go", flowgo_replacement(flowgo_version))
+ Go.mod_tidy()
- check_succeeded, check_results = \
- file.check(path, use_json=use_json, bench=bench)
- if check_results:
- result.check_result = CheckResult.from_dict(check_results[0])
- if use_json:
- results.append(result)
- if not check_succeeded:
- run_succeeded = False
- continue
+class Git:
- return run_succeeded, results
+ @staticmethod
+ def clone(url: str, branch: str, working_dir: Path):
+ if working_dir.exists():
+ Git._clean(working_dir)
+ logger.info(f"Cloning {url} ({branch})")
-class Git:
+ subprocess.run(
+ ["git", "clone", "--depth", "1", "--branch", branch, url, working_dir],
+ check=True
+ )
@staticmethod
- def clone(url: str, branch: str, working_dir: Path):
- subprocess.run([
- "git", "clone", "--depth", "1", "--branch",
- branch, url, working_dir
- ])
+ def _clean(working_dir: Path):
+ for root, dirs, files in os.walk(working_dir):
+ for dir in dirs:
+ os.chmod(os.path.join(root, dir), stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
+ for file in files:
+ os.chmod(os.path.join(root, file), stat.S_IRUSR | stat.S_IWUSR)
+ shutil.rmtree(working_dir)
@staticmethod
def get_head_ref() -> str:
completed_process = subprocess.run(
["git", "rev-parse", "--abbrev-ref", "HEAD"],
capture_output=True,
+ check=True
)
- if completed_process.returncode != 0:
- raise Exception('failed to get current Git ref')
return completed_process.stdout.decode("utf-8").strip()
- @staticmethod
- def checkout(ref: str):
- completed_process = subprocess.run(["git", "checkout", ref])
- if completed_process.returncode != 0:
- raise Exception(f'failed to checkout ref {ref}')
-
-
-def build(name):
- logger.info(f"Building {name}")
- subprocess.run(["go", "build", CMD_PATH / name])
-
-
-class EnhancedJSONEncoder(json.JSONEncoder):
- def default(self, o):
- if dataclasses.is_dataclass(o):
- return dataclasses.asdict(o)
- if isinstance(o, Enum):
- return o.value
- return super().default(o)
-
-
-def indent(text: str) -> str:
- return textwrap.indent(text, " ")
-
-
-def format_markdown_details(details: str) -> str:
- stripped = ansi_escape_pattern.sub('', details)
- escaped = html.escape(stripped).replace("\n", "
")
- return f"Details
{escaped}