From d1c1d8a2878e6609a4c955260ed8eab64aacae84 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Robin=20B=C3=A4rtschi?= Date: Thu, 13 Feb 2025 11:12:36 +0100 Subject: [PATCH] flakes and fixed some tests --- .gitignore | 1 + asm/amd64/amd64_test.go | 6 ++-- flake.lock | 26 +++++++++++++++ flake.nix | 71 +++++++++++++++++++++++++++++++++++++++++ ttir/ttir_test.go | 6 ++-- 5 files changed, 104 insertions(+), 6 deletions(-) create mode 100644 .gitignore create mode 100644 flake.lock create mode 100644 flake.nix diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b2be92b --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +result diff --git a/asm/amd64/amd64_test.go b/asm/amd64/amd64_test.go index 797ba98..ac21f6b 100644 --- a/asm/amd64/amd64_test.go +++ b/asm/amd64/amd64_test.go @@ -147,7 +147,7 @@ var basicTest string func TestCodegen(t *testing.T) { program := &ttir.Program{ - Functions: []ttir.Function{ + Functions: []*ttir.Function{ { Name: "main", HasReturnValue: true, @@ -193,7 +193,7 @@ var binaryTest string func TestBinary(t *testing.T) { program := &ttir.Program{ - Functions: []ttir.Function{ + Functions: []*ttir.Function{ { Name: "main", Instructions: []ttir.Instruction{ @@ -222,7 +222,7 @@ var equalityTest string // There was once a bug with how the cmp instructions were generated, this check should fail if it happens again func TestEqualityOperators(t *testing.T) { program := ttir.Program{ - Functions: []ttir.Function{ + Functions: []*ttir.Function{ { Name: "main", HasReturnValue: false, diff --git a/flake.lock b/flake.lock new file mode 100644 index 0000000..9191c49 --- /dev/null +++ b/flake.lock @@ -0,0 +1,26 @@ +{ + "nodes": { + "nixpkgs": { + "locked": { + "lastModified": 1739214665, + "narHash": "sha256-26L8VAu3/1YRxS8MHgBOyOM8xALdo6N0I04PgorE7UM=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "64e75cd44acf21c7933d61d7721e812eac1b5a0a", + "type": "github" + }, + "original": { + "id": "nixpkgs", + "ref": "nixos-unstable", + "type": "indirect" + } + }, + "root": { + "inputs": { + "nixpkgs": "nixpkgs" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/flake.nix b/flake.nix new file mode 100644 index 0000000..62d4194 --- /dev/null +++ b/flake.nix @@ -0,0 +1,71 @@ +{ + description = "A simple Go package"; + + # Nixpkgs / NixOS version to use. + inputs.nixpkgs.url = "nixpkgs/nixos-unstable"; + + outputs = { self, nixpkgs }: + let + + # to work with older version of flakes + lastModifiedDate = self.lastModifiedDate or self.lastModified or "19700101"; + + # Generate a user-friendly version number. + version = builtins.substring 0 8 lastModifiedDate; + + # System types to support. + supportedSystems = [ "x86_64-linux" "x86_64-darwin" "aarch64-linux" "aarch64-darwin" ]; + + # Helper function to generate an attrset '{ x86_64-linux = f "x86_64-linux"; ... }'. + forAllSystems = nixpkgs.lib.genAttrs supportedSystems; + + # Nixpkgs instantiated for supported system types. + nixpkgsFor = forAllSystems (system: import nixpkgs { inherit system; }); + + in + { + + # Provide some binary packages for selected system types. + packages = forAllSystems (system: + let + pkgs = nixpkgsFor.${system}; + in + { + tt = pkgs.buildGoModule { + pname = "tt"; + inherit version; + # In 'nix develop', we don't need a copy of the source tree + # in the Nix store. + src = ./.; + + # This hash locks the dependencies of this package. It is + # necessary because of how Go requires network access to resolve + # VCS. See https://www.tweag.io/blog/2021-03-04-gomod2nix/ for + # details. Normally one can build with a fake hash and rely on native Go + # mechanisms to tell you what the hash should be or determine what + # it should be "out-of-band" with other tooling (eg. gomod2nix). + # To begin with it is recommended to set this, but one must + # remember to bump this hash when your dependencies change. + # vendorHash = pkgs.lib.fakeHash; + + vendorHash = "sha256-cpjMZr+kP+XyXRxK4YI/lGHl97IROFVVz8DrID0vi6E="; + }; + }); + + # Add dependencies that are only needed for development + devShells = forAllSystems (system: + let + pkgs = nixpkgsFor.${system}; + in + { + default = pkgs.mkShell { + buildInputs = with pkgs; [ go gopls gotools go-tools ]; + }; + }); + + # The default package for 'nix build'. This makes sense if the + # flake provides only one package or there is a clear "main" + # package. + defaultPackage = forAllSystems (system: self.packages.${system}.tt); + }; +} diff --git a/ttir/ttir_test.go b/ttir/ttir_test.go index 3704a29..ad21159 100644 --- a/ttir/ttir_test.go +++ b/ttir/ttir_test.go @@ -58,7 +58,7 @@ func expectProgram(t *testing.T, expected *Program, actual *Program) { } } -func expectFunction(t *testing.T, expected Function, actual Function) { +func expectFunction(t *testing.T, expected *Function, actual *Function) { t.Helper() if expected.Name != actual.Name { @@ -133,7 +133,7 @@ func TestBasicFunction(t *testing.T) { runTTIREmitterTest(t, ttirEmitterTest{ input: "fn main() = 0;", expected: Program{ - Functions: []Function{ + Functions: []*Function{ { Name: "main", Instructions: []Instruction{ @@ -151,7 +151,7 @@ func TestBinaryExpression(t *testing.T) { runTTIREmitterTest(t, ttirEmitterTest{ input: "fn main() = 3 + 3 + 3;", expected: Program{ - Functions: []Function{ + Functions: []*Function{ {Name: "main", Instructions: []Instruction{ &Binary{Operator: ast.Add, Lhs: &Constant{Value: 3}, Rhs: &Constant{Value: 3}, Dst: &Var{Value: "temp.1"}}, &Binary{Operator: ast.Add, Lhs: &Var{Value: "temp.1"}, Rhs: &Constant{Value: 3}, Dst: &Var{Value: "temp.2"}},