Added immediate argument test

gen/immediate_argument.go

@@ -28,14 +28,14 @@ func (g *ImmediateArgumentGenerator[InstT]) Generate(
 	ctx *GenerationContext[InstT],
 	node parse.ImmediateNode,
 ) (ArgumentInfo, core.ResultList) {
-	typeName := string(node.Type.Raw(ctx.SourceContext))
+	typeName := string(node.Type.Identifier.Raw(ctx.SourceContext))
 	typ := ctx.Types.GetType(typeName)
 	if typ == nil {
 		return nil, list.FromSingle(NewUndefinedTypeResult(node.View()))
 	}
 
 	immediate, ok := node.Value.(parse.ImmediateFinalValueNode)
-	if !ok {
+	if !ok || len(node.Type.Decorators) > 0 {
 		v := node.View()
 		return nil, list.FromSingle(core.Result{{
 			Type:     core.ErrorResult,
@@ -44,7 +44,9 @@ func (g *ImmediateArgumentGenerator[InstT]) Generate(
 		}})
 	}
 
-	value, ok := new(big.Int).SetString(string(immediate.Raw(ctx.SourceContext)), 0)
+	immediate.Start += 1 // to skip the '#' character
+	valueStr := string(immediate.Raw(ctx.SourceContext))
+	value, ok := new(big.Int).SetString(valueStr, 0)
 	if !ok {
 		v := immediate.View()
 		return nil, list.FromSingle(core.Result{{

gen/immediate_arugment_test.go

@@ -0,0 +1,37 @@
+package gen_test
+
+import (
+	"testing"
+
+	"alon.kr/x/usm/core"
+	"alon.kr/x/usm/gen"
+	"alon.kr/x/usm/parse"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestImmediateValueArgument(t *testing.T) {
+	src := core.NewSourceView("$32 #1337")
+	unmanaged := src.Unmanaged()
+	node := parse.ImmediateNode{
+		Type: parse.TypeNode{
+			Identifier: unmanaged.Subview(0, 3),
+		},
+		Value: parse.ImmediateFinalValueNode{
+			UnmanagedSourceView: unmanaged.Subview(4, 9),
+		},
+	}
+
+	intType := &gen.TypeInfo{Name: "$32", Size: 4}
+	types := TypeMap{intType.Name: intType}
+
+	ctx := gen.GenerationContext[Instruction]{
+		SourceContext: src.Ctx(),
+		Types:         &types,
+		Registers:     &RegisterMap{},
+		Instructions:  &InstructionMap{},
+	}
+
+	generator := gen.ImmediateArgumentGenerator[Instruction]{}
+	_, results := generator.Generate(&ctx, node)
+	assert.True(t, results.IsEmpty())
+}

parse/immediate.go

@@ -155,30 +155,28 @@ type ImmediateBlockParser = BlockParser[ImmediateFieldNode]
 // MARK: Immediate
 
 type ImmediateNode struct {
-	Type  core.UnmanagedSourceView
+	Type  TypeNode
 	Value ImmediateValueNode
 }
 
 func (n ImmediateNode) View() core.UnmanagedSourceView {
-	return n.Type.MergeEnd(n.Value.View())
+	return n.Type.View().MergeEnd(n.Value.View())
 }
 
 func (n ImmediateNode) String(ctx *StringContext) string {
-	typ := string(n.Type.Raw(ctx.SourceContext))
-	val := n.Value.String(ctx)
-	return typ + " " + val
+	return n.Type.String(ctx) + " " + n.Value.String(ctx)
 }
 
 type ImmediateParser struct {
+	TypeParser
 	ImmediateValueParser *ImmediateValueParser
 }
 
 func (p ImmediateParser) Parse(v *TokenView) (node ImmediateNode, err core.Result) {
-	tkn, err := v.ConsumeToken(lex.TypeToken)
+	node.Type, err = p.TypeParser.Parse(v)
 	if err != nil {
 		return
 	}
-	node.Type = tkn.View
 
 	node.Value, err = p.ImmediateValueParser.Parse(v)
 	if err != nil {

parse/immediate_test.go

@@ -14,6 +14,11 @@ func TestImmediateValue(t *testing.T) {
 	testExpectedImmediate(t, src, src)
 }
 
+func TestImmediatePointerValue(t *testing.T) {
+	src := "$32 * #0"
+	testExpectedImmediate(t, src, src)
+}
+
 func TestImmediateBlockOneLine(t *testing.T) {
 	src := "$custom { .a #1337 .b #2902 }"
 	expected := `$custom {

parse/instruction_test.go

@@ -46,7 +46,9 @@ func TestInstructionWithImmediateValuesAndLabel(t *testing.T) {
 		Arguments: []parse.ArgumentNode{
 			parse.RegisterNode{unmanaged.Subview(22, 24)},
 			parse.ImmediateNode{
-				Type: unmanaged.Subview(25, 28),
+				Type: parse.TypeNode{
+					Identifier: unmanaged.Subview(25, 28),
+				},
 				Value: parse.ImmediateFinalValueNode{
 					unmanaged.Subview(29, 31),
 				},