Added a check for unused imports

src/build/compiler/Compile.go

@@ -5,15 +5,34 @@ import (
 
 	"git.akyoto.dev/cli/q/src/build/core"
 	"git.akyoto.dev/cli/q/src/build/errors"
+	"git.akyoto.dev/cli/q/src/build/fs"
 )
 
 // Compile waits for the scan to finish and compiles all functions.
-func Compile(functions <-chan *core.Function, errs <-chan error) (Result, error) {
+func Compile(files <-chan *fs.File, functions <-chan *core.Function, errs <-chan error) (Result, error) {
 	result := Result{}
-	all := map[string]*core.Function{}
+	allFunctions := map[string]*core.Function{}
+	allFiles := map[string]*fs.File{}
 
-	for functions != nil || errs != nil {
+	for functions != nil || files != nil || errs != nil {
 		select {
+		case function, ok := <-functions:
+			if !ok {
+				functions = nil
+				continue
+			}
+
+			function.Functions = allFunctions
+			allFunctions[function.Name] = function
+
+		case file, ok := <-files:
+			if !ok {
+				files = nil
+				continue
+			}
+
+			allFiles[file.Path] = file
+
 		case err, ok := <-errs:
 			if !ok {
 				errs = nil
@@ -21,23 +40,14 @@ func Compile(functions <-chan *core.Function, errs <-chan error) (Result, error)
 			}
 
 			return result, err
-
-		case function, ok := <-functions:
-			if !ok {
-				functions = nil
-				continue
-			}
-
-			function.Functions = all
-			all[function.Name] = function
 		}
 	}
 
 	// Start parallel compilation
-	CompileFunctions(all)
+	CompileFunctions(allFunctions)
 
 	// Report errors if any occurred
-	for _, function := range all {
+	for _, function := range allFunctions {
 		if function.Err != nil {
 			return result, function.Err
 		}
@@ -46,15 +56,24 @@ func Compile(functions <-chan *core.Function, errs <-chan error) (Result, error)
 		result.DataCount += len(function.Assembler.Data)
 	}
 
+	// Check for unused imports in all files
+	for _, file := range allFiles {
+		for _, pkg := range file.Imports {
+			if !pkg.Used {
+				return result, errors.New(&errors.UnusedImport{Package: pkg.Path}, file, pkg.Position)
+			}
+		}
+	}
+
 	// Check for existence of `main`
-	main, exists := all["main.main"]
+	main, exists := allFunctions["main.main"]
 
 	if !exists {
 		return result, errors.MissingMainFunction
 	}
 
 	result.Main = main
-	result.Functions = all
+	result.Functions = allFunctions
 	return result, nil
 }