Implemented environment type

src/compiler/Compile.go

@@ -9,11 +9,14 @@ import (
 
 // Compile waits for the scan to finish and compiles all functions.
 func Compile(constants <-chan *core.Constant, files <-chan *fs.File, functions <-chan *core.Function, structs <-chan *types.Struct, errs <-chan error) (Result, error) {
+	all := core.Environment{
+		Files:     make([]*fs.File, 0, 8),
+		Functions: make(map[string]*core.Function, 32),
+		Structs:   make(map[string]*types.Struct, 8),
+		Constants: make(map[string]*core.Constant, 8),
+	}
+
 	result := Result{}
-	allFiles := make([]*fs.File, 0, 8)
-	allFunctions := make(map[string]*core.Function, 32)
-	allStructs := make(map[string]*types.Struct, 8)
-	allConstants := make(map[string]*core.Constant, 8)
 
 	for constants != nil || files != nil || functions != nil || structs != nil || errs != nil {
 		select {
@@ -23,10 +26,8 @@ func Compile(constants <-chan *core.Constant, files <-chan *fs.File, functions <
 				continue
 			}
 
-			function.Functions = allFunctions
-			function.Structs = allStructs
-			function.Constants = allConstants
-			allFunctions[function.UniqueName] = function
+			function.All = &all
+			all.Functions[function.UniqueName] = function
 
 		case structure, ok := <-structs:
 			if !ok {
@@ -34,7 +35,7 @@ func Compile(constants <-chan *core.Constant, files <-chan *fs.File, functions <
 				continue
 			}
 
-			allStructs[structure.UniqueName] = structure
+			all.Structs[structure.UniqueName] = structure
 
 		case file, ok := <-files:
 			if !ok {
@@ -42,7 +43,7 @@ func Compile(constants <-chan *core.Constant, files <-chan *fs.File, functions <
 				continue
 			}
 
-			allFiles = append(allFiles, file)
+			all.Files = append(all.Files, file)
 
 		case constant, ok := <-constants:
 			if !ok {
@@ -50,7 +51,7 @@ func Compile(constants <-chan *core.Constant, files <-chan *fs.File, functions <
 				continue
 			}
 
-			allConstants[constant.Name] = constant
+			all.Constants[constant.Name] = constant
 
 		case err, ok := <-errs:
 			if !ok {
@@ -63,12 +64,12 @@ func Compile(constants <-chan *core.Constant, files <-chan *fs.File, functions <
 	}
 
 	// Calculate size of structs
-	for _, structure := range allStructs {
-		structure.Update(allStructs)
+	for _, structure := range all.Structs {
+		structure.Update(all.Structs)
 	}
 
 	// Resolve the types
-	for _, function := range allFunctions {
+	for _, function := range all.Functions {
 		err := function.ResolveTypes()
 
 		if err != nil {
@@ -77,10 +78,10 @@ func Compile(constants <-chan *core.Constant, files <-chan *fs.File, functions <
 	}
 
 	// Start parallel compilation
-	CompileFunctions(allFunctions)
+	CompileFunctions(all.Functions)
 
 	// Report errors if any occurred
-	for _, function := range allFunctions {
+	for _, function := range all.Functions {
 		if function.Err != nil {
 			return result, function.Err
 		}
@@ -90,7 +91,7 @@ func Compile(constants <-chan *core.Constant, files <-chan *fs.File, functions <
 	}
 
 	// Check for unused imports in all files
-	for _, file := range allFiles {
+	for _, file := range all.Files {
 		for _, pkg := range file.Imports {
 			if !pkg.Used {
 				return result, errors.New(&errors.UnusedImport{Package: pkg.Path}, file, pkg.Position)
@@ -99,14 +100,14 @@ func Compile(constants <-chan *core.Constant, files <-chan *fs.File, functions <
 	}
 
 	// Check for existence of `init`
-	init, exists := allFunctions["core.init"]
+	init, exists := all.Functions["core.init"]
 
 	if !exists {
 		return result, errors.MissingInitFunction
 	}
 
 	// Check for existence of `main`
-	main, exists := allFunctions["main.main"]
+	main, exists := all.Functions["main.main"]
 
 	if !exists {
 		return result, errors.MissingMainFunction
@@ -114,7 +115,7 @@ func Compile(constants <-chan *core.Constant, files <-chan *fs.File, functions <
 
 	result.Init = init
 	result.Main = main
-	result.Functions = allFunctions
+	result.Functions = all.Functions
 	result.finalize()
 	return result, nil
 }