Refactor error messages and logging for consistency

- Updated various error messages and debug logs to use lowercase for improved readability and consistency across the codebase.
- Removed the constants file for report messages as it was deemed unnecessary.
- Adjusted import paths in test utilities to reflect changes in configuration.
- Ensured that all error messages related to type checking, resolution, and imports follow a uniform style.

Author: itsfuad

compiler/cmd/cli/executor.go

@@ -3,7 +3,6 @@ package cli
 import (
 	"compiler/cmd"
 	"compiler/colors"
-	"compiler/constants"
 	"compiler/internal/modules"
 	"fmt"
 	"os"
@@ -270,7 +269,7 @@ func getRoot() string {
 	}
 
 	// Enforce: must be run from project root (directory containing fer.ret)
-	ferretPath := filepath.Join(cwd, constants.CONFIG_FILE)
+	ferretPath := filepath.Join(cwd, config.CONFIG_FILE)
 	if _, err := os.Stat(ferretPath); err != nil {
 		colors.RED.Printf(CONFIG_LOAD_ERROR, err)
 		os.Exit(1)

compiler/cmd/compiler.go

@@ -11,7 +11,6 @@ import (
 	"compiler/cmd/flags"
 	"compiler/colors"
 	"compiler/config"
-	"compiler/constants"
 	"compiler/internal/ctx"
 	"compiler/internal/modules"
 
@@ -146,7 +145,7 @@ func getRemoteDependencyPath(projectConfig *config.ProjectConfig, depKey string)
 	host, owner, repo := repoParts[0], repoParts[1], repoParts[2]
 
 	// Construct cache path
-	cachePath := filepath.Join(projectConfig.ProjectRoot, constants.CACHE_DIR)
+	cachePath := filepath.Join(projectConfig.ProjectRoot, config.CACHE_DIR)
 	return filepath.Join(cachePath, host, owner, modules.BuildPackageSpec(repo, version))
 }
 

compiler/config/project.go

@@ -9,14 +9,24 @@ import (
 
 	"compiler/cmd/flags"
 	"compiler/colors"
-	"compiler/constants"
 	"compiler/toml"
 )
 
 const SHAREKEY = "allow-sharing"
 const REMOTEKEY = "allow-remote-import"
 const EXTERNALKEY = "allow-neighbor-import"
 
+const (
+	EXT              = ".fer"
+	CACHE_DIR        = ".ferret"
+	CONFIG_FILE      = "fer.ret"
+	LOCKFILE         = "ferret.lock"
+	LOCKFILE_VERSION = "1.0.0"
+	GITHUB_HOST      = "github.com"
+
+	STD_LIBS_PATH = "modules"
+)
+
 // ProjectConfig represents the structure
 type ProjectConfig struct {
 	Name         string           `toml:"name"`
@@ -84,7 +94,7 @@ func (conf *ProjectConfig) Save() error {
 	}
 
 	// Save the configuration to the fer.ret file
-	if err := toml.WriteTOMLFile(filepath.Join(conf.ProjectRoot, constants.CONFIG_FILE), tomData, nil); err != nil {
+	if err := toml.WriteTOMLFile(filepath.Join(conf.ProjectRoot, CONFIG_FILE), tomData, nil); err != nil {
 		colors.RED.Println(err)
 		return fmt.Errorf("failed to save config file: %w", err)
 	}
@@ -131,7 +141,7 @@ func CreateDefaultProjectConfig(projectName string) error {
 		os.Exit(1)
 	}
 
-	configPath := filepath.Join(cwd, constants.CONFIG_FILE)
+	configPath := filepath.Join(cwd, CONFIG_FILE)
 
 	// if already exist, ask for overwrite
 	if _, err := os.Stat(configPath); err == nil {
@@ -161,7 +171,7 @@ func CreateDefaultProjectConfig(projectName string) error {
 		os.Exit(1)
 	}
 
-	colors.GREEN.Printf("📁 Created %s successfully!\n", constants.CONFIG_FILE)
+	colors.GREEN.Printf("📁 Created %s successfully!\n", CONFIG_FILE)
 
 	// remove old lockfiles and cache
 	if err := os.RemoveAll(filepath.Join(cwd, ".ferret")); err != nil {
@@ -315,7 +325,7 @@ func ValidateProjectConfig(config *ProjectConfig) error {
 
 // IsProjectRoot checks if the given directory contains a fer.ret file
 func IsProjectRoot(dir string) bool {
-	configPath := filepath.Join(dir, constants.CONFIG_FILE)
+	configPath := filepath.Join(dir, CONFIG_FILE)
 	_, err := os.Stat(filepath.FromSlash(configPath))
 	return err == nil
 }
@@ -331,7 +341,7 @@ func GetProjectRoot(filePath string) (string, error) {
 
 	// Walk up the directory tree until we find a fer.ret file
 	for {
-		configPath := filepath.Join(dir, constants.CONFIG_FILE)
+		configPath := filepath.Join(dir, CONFIG_FILE)
 		// Check if fer.ret exists in this directory
 		if _, err := os.Stat(configPath); err == nil {
 			// Found the project root
@@ -349,7 +359,7 @@ func GetProjectRoot(filePath string) (string, error) {
 		dir = parent
 	}
 
-	return "", fmt.Errorf("❌ %s not found (searched from: %s up to filesystem root)", constants.CONFIG_FILE, dir)
+	return "", fmt.Errorf("❌ %s not found (searched from: %s up to filesystem root)", CONFIG_FILE, dir)
 }
 
 func LoadProjectConfig(projectRoot string) (*ProjectConfig, error) {
@@ -360,11 +370,11 @@ func LoadProjectConfig(projectRoot string) (*ProjectConfig, error) {
 		os.Exit(1)
 	}
 
-	configPath := filepath.Join(projectRoot, constants.CONFIG_FILE)
+	configPath := filepath.Join(projectRoot, CONFIG_FILE)
 
 	// if not exists, ask user to create one
 	if _, err := os.Stat(configPath); os.IsNotExist(err) {
-		colors.RED.Printf("❌ Configuration file %s not found in %s\nCreate project by running 'ferret init' command\n", constants.CONFIG_FILE, projectRoot)
+		colors.RED.Printf("❌ Configuration file %s not found in %s\nCreate project by running 'ferret init' command\n", CONFIG_FILE, projectRoot)
 	}
 
 	// Use our custom TOML parser

compiler/config/project_test.go

@@ -1,7 +1,6 @@
 package config
 
 import (
-	"compiler/constants"
 	"compiler/toml"
 	"os"
 	"path/filepath"
@@ -111,7 +110,7 @@ func TestIsProjectRoot(t *testing.T) {
 	}
 	defer os.RemoveAll(tempDir)
 
-	configPath := filepath.Join(tempDir, constants.CONFIG_FILE)
+	configPath := filepath.Join(tempDir, CONFIG_FILE)
 	if err := os.WriteFile(configPath, []byte("test"), 0644); err != nil {
 		t.Fatalf("Failed to create config file: %v", err)
 	}
@@ -208,7 +207,7 @@ func setupTestProjectStructure(t *testing.T) string {
 	}
 
 	// Create config file in root
-	configPath := filepath.Join(tempDir, constants.CONFIG_FILE)
+	configPath := filepath.Join(tempDir, CONFIG_FILE)
 	if err := os.WriteFile(configPath, []byte("test"), 0644); err != nil {
 		t.Fatalf("Failed to create config file: %v", err)
 	}

compiler/constants/constants_names.go

@@ -9,7 +9,6 @@ import (
 
 	"compiler/colors"
 	"compiler/config"
-	"compiler/constants"
 	"compiler/internal/frontend/ast"
 	"compiler/internal/modules"
 	"compiler/internal/symbol"
@@ -155,7 +154,7 @@ func (c *CompilerContext) validateResolvedPath(resolvedPath, importPath string)
 	}
 
 	// Add extension and check if file exists
-	finalPath := resolvedPath + constants.EXT
+	finalPath := resolvedPath + config.EXT
 	if !fs.IsValidFile(finalPath) {
 		fmt.Printf("Final path: %s\n", finalPath)
 		return "", fmt.Errorf("module %q does not exist", importPath)
@@ -421,7 +420,7 @@ func NewCompilerContext(projectConfig *config.ProjectConfig) *CompilerContext {
 	entryPoint = filepath.ToSlash(entryPoint) // Ensure forward slashes for consistency
 
 	// Set up remote module cache path
-	remoteCachePath := filepath.Join(projectConfig.ProjectRoot, constants.CACHE_DIR)
+	remoteCachePath := filepath.Join(projectConfig.ProjectRoot, config.CACHE_DIR)
 	remoteCachePath = filepath.ToSlash(remoteCachePath)
 	os.MkdirAll(remoteCachePath, 0755)
 

compiler/internal/ctx/context.go

@@ -21,8 +21,8 @@ const (
 	mainEntry          = "main.fer"
 	mainOutput         = "main.exe"
 	ferretCacheDir     = ".ferret"
-	expectedPanicMsg   = "Expected panic but didn't get one"
-	expectedNonNilCtx  = "Expected non-nil context"
+	expectedPanicMsg   = "expected panic but didn't get one"
+	expectedNonNilCtx  = "expected non-nil context"
 )
 
 // Test helper to create a temporary project config
@@ -60,7 +60,7 @@ func createTempDir(t *testing.T) string {
 	t.Helper()
 	dir, err := os.MkdirTemp("", "ferret-test-")
 	if err != nil {
-		t.Fatalf("Failed to create temp dir: %v", err)
+		t.Fatalf("failed to create temp dir: %v", err)
 	}
 	t.Cleanup(func() {
 		os.RemoveAll(dir)

compiler/internal/ctx/context_test.go

@@ -15,7 +15,7 @@ func parseExpressionList(p *Parser, first ast.Expression) ast.ExpressionList {
 		next := parseExpression(p)
 		if next == nil {
 			token := p.peek()
-			p.ctx.Reports.AddSyntaxError(p.fullPath, source.NewLocation(&token.Start, &token.End), "Expected expression after comma", report.PARSING_PHASE)
+			p.ctx.Reports.AddSyntaxError(p.fullPath, source.NewLocation(&token.Start, &token.End), "expected expression after comma", report.PARSING_PHASE)
 			break
 		}
 		exprs = append(exprs, next)
@@ -40,7 +40,7 @@ func parseExpressionStatement(p *Parser, first ast.Expression) ast.Statement {
 
 // parseBlock parses a block of statements
 func parseBlock(p *Parser) *ast.Block {
-	start := p.consume(lexer.OPEN_CURLY, report.EXPECTED_OPEN_BRACE).Start
+	start := p.consume(lexer.OPEN_CURLY, "expected '{' before block").Start
 
 	nodes := make([]ast.Node, 0)
 
@@ -51,7 +51,7 @@ func parseBlock(p *Parser) *ast.Block {
 		}
 	}
 
-	end := p.consume(lexer.CLOSE_CURLY, report.EXPECTED_CLOSE_BRACE).End
+	end := p.consume(lexer.CLOSE_CURLY, "expected '}' after block").End
 
 	return &ast.Block{
 		Nodes:    nodes,
@@ -60,7 +60,9 @@ func parseBlock(p *Parser) *ast.Block {
 }
 
 func parseReturnStmt(p *Parser) ast.Statement {
-	start := p.consume(lexer.RETURN_TOKEN, report.EXPECTED_RETURN_KEYWORD).Start
+
+	start := p.advance().Start // consume 'return' and get start position
+
 	end := start
 
 	// Return immediately if there's a semicolon (no return value)
@@ -78,7 +80,7 @@ func parseReturnStmt(p *Parser) ast.Statement {
 		p.ctx.Reports.AddSyntaxError(
 			p.fullPath,
 			source.NewLocation(&token.Start, &token.End),
-			report.INVALID_EXPRESSION,
+			"invalid expression after return keyword",
 			report.PARSING_PHASE,
 		).AddHint("add an expression after the return keyword")
 
@@ -96,7 +98,7 @@ func parseReturnStmt(p *Parser) ast.Statement {
 		p.ctx.Reports.AddSyntaxError(
 			p.fullPath,
 			source.NewLocation(&comma.Start, &comma.End),
-			"Multiple return values are not supported",
+			"multiple return values are not supported",
 			report.PARSING_PHASE,
 		).AddHint("functions can only return a single value")
 
@@ -281,26 +283,26 @@ func handlePlusMinus(p *Parser) ast.Expression {
 	operator := p.advance()
 	// Check for consecutive operators
 	if p.match(lexer.PLUS_PLUS_TOKEN, lexer.MINUS_MINUS_TOKEN) {
-		errMsg := report.INVALID_CONSECUTIVE_INCREMENT
+		errMsg := "invalid consecutive increment operators"
 		if operator.Kind == lexer.MINUS_MINUS_TOKEN {
-			errMsg = report.INVALID_CONSECUTIVE_DECREMENT
+			errMsg = "invalid consecutive decrement operators"
 		}
 		p.ctx.Reports.AddSyntaxError(p.fullPath, source.NewLocation(&operator.Start, &operator.End), errMsg, report.PARSING_PHASE)
 		return nil
 	}
 	operand := parseUnary(p)
 	if operand == nil {
-		errMsg := report.INVALID_INCREMENT_OPERAND
+		errMsg := "invalid operand for increment operator"
 		if operator.Kind == lexer.MINUS_MINUS_TOKEN {
-			errMsg = report.INVALID_DECREMENT_OPERAND
+			errMsg = "invalid operand for decrement operator"
 		}
 		p.ctx.Reports.AddSyntaxError(p.fullPath, source.NewLocation(&operator.Start, &operator.End), errMsg, report.PARSING_PHASE)
 		return nil
 	}
 
 	// Check if operand already has a postfix operator
 	if _, ok := operand.(*ast.PostfixExpr); ok {
-		p.ctx.Reports.AddSyntaxError(p.fullPath, source.NewLocation(&operator.Start, &operator.End), "Cannot mix prefix and postfix operators", report.PARSING_PHASE)
+		p.ctx.Reports.AddSyntaxError(p.fullPath, source.NewLocation(&operator.Start, &operator.End), "cannot mix prefix and postfix operators", report.PARSING_PHASE)
 		return nil
 	}
 
@@ -316,7 +318,7 @@ func handleSpread(p *Parser) ast.Expression {
 	operator := p.advance()
 	right := parseUnary(p)
 	if right == nil {
-		p.ctx.Reports.AddSyntaxError(p.fullPath, source.NewLocation(&operator.Start, &operator.End), "Expected expression after spread operator", report.PARSING_PHASE)
+		p.ctx.Reports.AddSyntaxError(p.fullPath, source.NewLocation(&operator.Start, &operator.End), "expected expression after spread operator", report.PARSING_PHASE)
 		return nil
 	}
 
@@ -334,7 +336,7 @@ func parseCast(p *Parser) ast.Expression {
 		asToken := p.advance()
 		targetType, ok := parseType(p)
 		if !ok || targetType == nil {
-			p.ctx.Reports.AddSyntaxError(p.fullPath, source.NewLocation(&asToken.Start, &asToken.End), "Expected type after 'as' keyword", report.PARSING_PHASE)
+			p.ctx.Reports.AddSyntaxError(p.fullPath, source.NewLocation(&asToken.Start, &asToken.End), "expected type after 'as' keyword", report.PARSING_PHASE)
 			return expr
 		}
 
@@ -356,11 +358,11 @@ func parseIndexing(p *Parser, expr ast.Expression) (ast.Expression, bool) {
 	index := parseExpression(p)
 	if index == nil {
 		token := p.peek()
-		p.ctx.Reports.AddSyntaxError(p.fullPath, source.NewLocation(&token.Start, &token.End), report.MISSING_INDEX_EXPRESSION, report.PARSING_PHASE)
+		p.ctx.Reports.AddSyntaxError(p.fullPath, source.NewLocation(&token.Start, &token.End), "expected valid indexing expression", report.PARSING_PHASE)
 		return nil, false
 	}
 
-	end := p.consume(lexer.CLOSE_BRACKET, report.EXPECTED_CLOSE_BRACKET)
+	end := p.consume(lexer.CLOSE_BRACKET, "expected ']' after index expression")
 	return &ast.IndexableExpr{
 		Indexable: &expr,
 		Index:     &index,
@@ -372,9 +374,9 @@ func parseIndexing(p *Parser, expr ast.Expression) (ast.Expression, bool) {
 func parseIncDec(p *Parser, expr ast.Expression) (ast.Expression, bool) {
 	operator := p.advance()
 	if p.match(lexer.PLUS_PLUS_TOKEN, lexer.MINUS_MINUS_TOKEN) {
-		errMsg := report.INVALID_CONSECUTIVE_INCREMENT
+		errMsg := "invalid consecutive increment operators"
 		if operator.Kind == lexer.MINUS_MINUS_TOKEN {
-			errMsg = report.INVALID_CONSECUTIVE_DECREMENT
+			errMsg = "invalid consecutive decrement operators"
 		}
 		p.ctx.Reports.AddSyntaxError(p.fullPath, source.NewLocation(&operator.Start, &operator.End), errMsg, report.PARSING_PHASE)
 		return nil, false
@@ -391,7 +393,7 @@ func handlePostfixOperator(p *Parser, expr ast.Expression) (ast.Expression, bool
 	if p.match(lexer.PLUS_PLUS_TOKEN, lexer.MINUS_MINUS_TOKEN) {
 		if _, ok := expr.(*ast.PrefixExpr); ok {
 			current := p.peek()
-			p.ctx.Reports.AddSyntaxError(p.fullPath, source.NewLocation(&current.Start, &current.End), "Cannot mix prefix and postfix operators", report.PARSING_PHASE)
+			p.ctx.Reports.AddSyntaxError(p.fullPath, source.NewLocation(&current.Start, &current.End), "cannot mix prefix and postfix operators", report.PARSING_PHASE)
 			return nil, false
 		}
 		return parseIncDec(p, expr)
@@ -441,7 +443,7 @@ func parsePostfix(p *Parser) ast.Expression {
 func parseGrouping(p *Parser) ast.Expression {
 	p.advance() // consume '('
 	expr := parseExpression(p)
-	p.consume(lexer.CLOSE_PAREN, "Expected ')' after expression")
+	p.consume(lexer.CLOSE_PAREN, "expected ')' after expression")
 	return expr
 }
 
@@ -456,23 +458,23 @@ func parseFunctionCall(p *Parser, caller ast.Expression) (ast.Expression, bool)
 		arg := parseExpression(p)
 		if arg == nil {
 			token := p.peek()
-			p.ctx.Reports.AddSyntaxError(p.fullPath, source.NewLocation(&token.Start, &token.End), "Expected function argument", report.PARSING_PHASE)
+			p.ctx.Reports.AddSyntaxError(p.fullPath, source.NewLocation(&token.Start, &token.End), "expected function argument", report.PARSING_PHASE)
 			return nil, false
 		}
 		arguments = append(arguments, arg)
 
 		if p.match(lexer.CLOSE_PAREN) {
 			break
 		} else {
-			comma := p.consume(lexer.COMMA_TOKEN, report.EXPECTED_COMMA_OR_CLOSE_PAREN)
+			comma := p.consume(lexer.COMMA_TOKEN, "expected ',' or ')' after parameter")
 			if p.match(lexer.CLOSE_PAREN) {
-				p.ctx.Reports.AddWarning(p.fullPath, source.NewLocation(&comma.Start, &comma.End), report.TRAILING_COMMA_NOT_ALLOWED, report.PARSING_PHASE).AddHint("remove the trailing comma")
+				p.ctx.Reports.AddWarning(p.fullPath, source.NewLocation(&comma.Start, &comma.End), "unnecessary trailing comma after last argument", report.PARSING_PHASE).AddHint("remove the trailing comma")
 				break
 			}
 		}
 	}
 
-	end := p.consume(lexer.CLOSE_PAREN, report.EXPECTED_CLOSE_PAREN)
+	end := p.consume(lexer.CLOSE_PAREN, "expected ')' after function arguments")
 
 	return &ast.FunctionCallExpr{
 		Caller:    &caller,