fix linting errors

.golangci.yml

@@ -1,4 +1,4 @@
 run:
   skip-files:
     - pkg/assembler/grammar.go
-    - pkg/hintrunner/hintparser.go
+    - pkg/hintrunner/zero/hintparser.go

cmd/cli/main.go

@@ -5,7 +5,7 @@ import (
 	"math"
 	"os"
 
-	hintrunner "github.com/NethermindEth/cairo-vm-go/pkg/hintrunner"
+	hintrunner "github.com/NethermindEth/cairo-vm-go/pkg/hintrunner/zero"
 	zero "github.com/NethermindEth/cairo-vm-go/pkg/parsers/zero"
 	runnerzero "github.com/NethermindEth/cairo-vm-go/pkg/runners/zero"
 	"github.com/urfave/cli/v2"

pkg/hintrunner/core/hint_benchmark_test.go

@@ -49,7 +49,7 @@ func BenchmarkLessThan(b *testing.B) {
 			vm.Context.Ap+uint64(rhsRef),
 			memory.MemoryValueFromInt(rand.Int63()),
 		)
-		rhs := hinter.Deref{rhsRef}
+		rhs := hinter.Deref{Deref: rhsRef}
 		lhs := hinter.Immediate(utils.RandomFeltElement(rand))
 
 		hint := TestLessThan{
@@ -394,7 +394,7 @@ func BenchmarkAssertLeFindSmallArc(b *testing.B) {
 		hint := AssertLeFindSmallArc{
 			a:             hinter.Immediate(r1),
 			b:             hinter.Immediate(r2),
-			rangeCheckPtr: hinter.Deref{hinter.ApCellRef(0)},
+			rangeCheckPtr: hinter.Deref{Deref: hinter.ApCellRef(0)},
 		}
 
 		if err := hint.Execute(vm, &ctx); err != nil &&

pkg/hintrunner/core/hint_test.go

@@ -55,7 +55,7 @@ func TestTestLessThanTrue(t *testing.T) {
 
 	var dst hinter.ApCellRef = 1
 	var rhsRef hinter.FpCellRef = 0
-	rhs := hinter.Deref{rhsRef}
+	rhs := hinter.Deref{Deref: rhsRef}
 
 	lhs := hinter.Immediate(f.NewElement(13))
 
@@ -92,7 +92,7 @@ func TestTestLessThanFalse(t *testing.T) {
 
 			var dst hinter.ApCellRef = 1
 			var rhsRef hinter.FpCellRef = 0
-			rhs := hinter.Deref{rhsRef}
+			rhs := hinter.Deref{Deref: rhsRef}
 
 			lhs := hinter.Immediate(tc.lhsValue)
 			hint := TestLessThan{
@@ -131,7 +131,7 @@ func TestTestLessThanOrEqTrue(t *testing.T) {
 
 			var dst hinter.ApCellRef = 1
 			var rhsRef hinter.FpCellRef = 0
-			rhs := hinter.Deref{rhsRef}
+			rhs := hinter.Deref{Deref: rhsRef}
 
 			lhs := hinter.Immediate(tc.lhsValue)
 			hint := TestLessThanOrEqual{
@@ -160,7 +160,7 @@ func TestTestLessThanOrEqFalse(t *testing.T) {
 
 	var dst hinter.ApCellRef = 1
 	var rhsRef hinter.FpCellRef = 0
-	rhs := hinter.Deref{rhsRef}
+	rhs := hinter.Deref{Deref: rhsRef}
 
 	lhs := hinter.Immediate(f.NewElement(32))
 
@@ -546,8 +546,8 @@ func TestDebugPrint(t *testing.T) {
 
 	var starRef hinter.ApCellRef = 0
 	var endRef hinter.ApCellRef = 1
-	start := hinter.Deref{starRef}
-	end := hinter.Deref{endRef}
+	start := hinter.Deref{Deref: starRef}
+	end := hinter.Deref{Deref: endRef}
 	hint := DebugPrint{
 		start: start,
 		end:   end,
@@ -991,7 +991,7 @@ func TestAssertLeFindSmallArc(t *testing.T) {
 		hint := AssertLeFindSmallArc{
 			a:             hinter.Immediate(tc.aFelt),
 			b:             hinter.Immediate(tc.bFelt),
-			rangeCheckPtr: hinter.Deref{hinter.ApCellRef(0)},
+			rangeCheckPtr: hinter.Deref{Deref: hinter.ApCellRef(0)},
 		}
 
 		ctx := hinter.HintRunnerContext{

pkg/hintrunner/hintrunner.go

@@ -20,10 +20,10 @@ func NewHintRunner(hints map[uint64]h.Hinter) HintRunner {
 		// Context for certain hints that require it. Each manager is
 		// initialized only when required by the hint
 		context: h.HintRunnerContext{
-			h.DictionaryManager{},
-			h.SquashedDictionaryManager{},
-			0,
-			mem.UnknownAddress,
+			DictionaryManager:         h.DictionaryManager{},
+			SquashedDictionaryManager: h.SquashedDictionaryManager{},
+			ExcludedArc:               0,
+			ConstantSizeSegment:       mem.UnknownAddress,
 		},
 		hints: hints,
 	}

pkg/hintrunner/zero/hintparser.go

@@ -111,17 +111,17 @@ func (expression DerefCastExp) Evaluate() (any, error) {
 
 	switch result := value.(type) {
 	case op.CellRefer:
-		return op.Deref{result}, nil
+		return op.Deref{Deref: result}, nil
 	case op.Deref:
 		return op.DoubleDeref{
-			result.Deref,
-			0,
+			Deref:  result.Deref,
+			Offset: 0,
 		},
 		nil		
 	case DerefOffset:
 		return op.DoubleDeref{
-			result.Deref.Deref,
-			int16(*result.Offset),
+			Deref:  result.Deref.Deref,
+			Offset: int16(*result.Offset),
 		},
 		nil
 	default:
@@ -142,9 +142,9 @@ func (expression CastExp) Evaluate() (any, error) {
 		return result, nil
 	case DerefOffset:
 		return op.BinaryOp{
-			0,
-			result.Deref.Deref,
-			op.Immediate{
+			Operator: 0,
+			Lhs:      result.Deref.Deref,
+			Rhs:      op.Immediate{
 				uint64(0),
 				uint64(0),
 				uint64(0),
@@ -153,9 +153,9 @@ func (expression CastExp) Evaluate() (any, error) {
 		}, nil
 	case DerefDeref:
 		return op.BinaryOp{
-			0,
-			result.LeftDeref.Deref,
-			result.RightDeref,
+			Operator: 0,
+			Lhs:      result.LeftDeref.Deref,
+			Rhs:      result.RightDeref,
 		}, nil
 	default:
 		return nil, fmt.Errorf("unexpected identifier value")
@@ -225,7 +225,7 @@ func (expression DerefExp) Evaluate() (any, error) {
 	if !ok {
 		return nil, fmt.Errorf("Expected a CellRefer expression but got %s", cellRefExp)
 	}
-	return op.Deref{cellRef}, nil
+	return op.Deref{Deref: cellRef}, nil
 }
 
 func (expression BinOpExp) Evaluate() (any, error) {