feat: gasm-devkit 0.1.0 — GAsm lexer, parser, linter, formatter, LSP and amd64 assembler

Assisted-by: Qwen 3.8 Max Preview

lexer/lexer_test.go

@@ -0,0 +1,155 @@
+// Copyright (c) 2026 Petr Balvín <opensource@petrbalvin.org> (https://petrbalvin.org)
+// SPDX-License-Identifier: BSD-3-Clause
+
+package lexer
+
+import (
+	"testing"
+
+	"sourcedock.dev/petrbalvin/gasm-devkit/token"
+)
+
+// kinds tokenizes src and returns the kind sequence, dropping Newline/EOF.
+func kinds(src string) []token.Kind {
+	var out []token.Kind
+	for _, t := range Tokenize(src) {
+		if t.Kind == token.Newline || t.Kind == token.EOF {
+			continue
+		}
+		out = append(out, t.Kind)
+	}
+	return out
+}
+
+// texts tokenizes src and returns the literal text of each significant token.
+func texts(src string) []string {
+	var out []string
+	for _, t := range Tokenize(src) {
+		if t.Kind == token.Newline || t.Kind == token.EOF {
+			continue
+		}
+		out = append(out, t.Text)
+	}
+	return out
+}
+
+func eq[T comparable](t *testing.T, got, want []T) {
+	t.Helper()
+	if len(got) != len(want) {
+		t.Fatalf("length mismatch:\n got  %v\n want %v", got, want)
+	}
+	for i := range got {
+		if got[i] != want[i] {
+			t.Fatalf("index %d:\n got  %v\n want %v", i, got, want)
+		}
+	}
+}
+
+func TestTextDirective(t *testing.T) {
+	eq(t, texts("TEXT ·analyzeO1RangeAVX2(SB), NOSPLIT, $0-65"),
+		[]string{"TEXT", "·analyzeO1RangeAVX2", "(", "SB", ")", ",", "NOSPLIT", ",", "$", "0", "-", "65"})
+}
+
+func TestDataAndGlobl(t *testing.T) {
+	eq(t, texts("GLOBL ·idx16(SB), RODATA, $64"),
+		[]string{"GLOBL", "·idx16", "(", "SB", ")", ",", "RODATA", ",", "$", "64"})
+	eq(t, texts("DATA ·idx16+0(SB)/4, $1"),
+		[]string{"DATA", "·idx16", "+", "0", "(", "SB", ")", "/", "4", ",", "$", "1"})
+}
+
+func TestStaticSymbol(t *testing.T) {
+	// mask24<> is a file-local symbol; <> must lex as two angle tokens.
+	eq(t, texts("GLOBL mask24<>(SB), RODATA, $16"),
+		[]string{"GLOBL", "mask24", "<", ">", "(", "SB", ")", ",", "RODATA", ",", "$", "16"})
+}
+
+func TestNegativeImmediate(t *testing.T) {
+	eq(t, texts("ANDQ $-8, R10"),
+		[]string{"ANDQ", "$", "-", "8", ",", "R10"})
+}
+
+func TestHexImmediate(t *testing.T) {
+	eq(t, texts("DATA mask24<>+0(SB)/4, $0x80020100"),
+		[]string{"DATA", "mask24", "<", ">", "+", "0", "(", "SB", ")", "/", "4", ",", "$", "0x80020100"})
+}
+
+func TestMemoryAddressing(t *testing.T) {
+	eq(t, texts("LEAQ (SI)(BX*4), R9"),
+		[]string{"LEAQ", "(", "SI", ")", "(", "BX", "*", "4", ")", ",", "R9"})
+	eq(t, texts("VMOVDQU32 Z0, 4(SI)(AX*1)"),
+		[]string{"VMOVDQU32", "Z0", ",", "4", "(", "SI", ")", "(", "AX", "*", "1", ")"})
+}
+
+func TestLabelAndComment(t *testing.T) {
+	eq(t, kinds("vec1:\n\tJMP vec1 // loop"),
+		[]token.Kind{token.Ident, token.Colon, token.Ident, token.Ident, token.Comment})
+}
+
+func TestAVX512Mnemonics(t *testing.T) {
+	eq(t, texts("VFMADD231PD Z14, Z12, Z10"),
+		[]string{"VFMADD231PD", "Z14", ",", "Z12", ",", "Z10"})
+	eq(t, texts("KTESTW K1, K1"),
+		[]string{"KTESTW", "K1", ",", "K1"})
+}
+
+func TestArm64Shifts(t *testing.T) {
+	eq(t, texts("ADD R0<<2, R1, R2"),
+		[]string{"ADD", "R0", "<<", "2", ",", "R1", ",", "R2"})
+	eq(t, texts("MOVD R3->4, R5"),
+		[]string{"MOVD", "R3", "->", "4", ",", "R5"})
+}
+
+func TestInclude(t *testing.T) {
+	eq(t, texts(`#include "textflag.h"`),
+		[]string{"#", "include", `"textflag.h"`})
+}
+
+func TestPositions(t *testing.T) {
+	toks := Tokenize("MOVQ AX, BX\nRET")
+	// Find RET and check it landed on line 2.
+	var ret token.Token
+	for _, tok := range toks {
+		if tok.Text == "RET" {
+			ret = tok
+		}
+	}
+	if ret.Pos.Line != 2 || ret.Pos.Column != 1 {
+		t.Fatalf("RET position = %v, want 2:1", ret.Pos)
+	}
+}
+
+func TestIllegalNeverPanics(t *testing.T) {
+	// A stray backtick and NUL-ish garbage must not crash the scanner.
+	toks := Tokenize("MOVQ ` , \x01 AX")
+	if len(toks) == 0 {
+		t.Fatal("expected tokens")
+	}
+}
+
+func TestBlockComment(t *testing.T) {
+	eq(t, kinds("MOVQ /* inline */ AX"),
+		[]token.Kind{token.Ident, token.Comment, token.Ident})
+	// An unterminated block comment is tolerated.
+	toks := Tokenize("MOVQ /* never closed")
+	if toks[len(toks)-2].Kind != token.Comment {
+		t.Errorf("expected a comment token, got %v", toks)
+	}
+}
+
+func TestRuneLiteral(t *testing.T) {
+	eq(t, texts("MOVL $'a', AX"),
+		[]string{"MOVL", "$", "'a'", ",", "AX"})
+}
+
+func TestFloatAndBases(t *testing.T) {
+	eq(t, texts("$1.5"), []string{"$", "1.5"})
+	eq(t, texts("$0b1010"), []string{"$", "0b1010"})
+	eq(t, texts("$0o755"), []string{"$", "0o755"})
+	eq(t, texts("$1e3"), []string{"$", "1e3"})
+}
+
+func TestOperatorVariants(t *testing.T) {
+	eq(t, texts("R0>>2"), []string{"R0", ">>", "2"})
+	eq(t, texts("@>"), []string{"@", ">"})
+	eq(t, texts("a/b"), []string{"a", "/", "b"})
+}