Refactor proper ast #18 (#20)

* refactor: migration to proper AST
* refactor: Parse function expressions
* extern docs
* improved docs
* relative errors
* centralize function calls
* nicer stack traces
* bump dependencies
* remove old interpreter
* improved error handling

Author: vknabel

.vscode/launch.json

@@ -1,49 +1,45 @@
 {
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "name": "Write docs",
-            "type": "go",
-            "request": "launch",
-            "mode": "auto",
-            "program": "${workspaceFolder}/cmd/lithia/main.go",
-            "args": [
-                "${workspaceFolder}/stdlib/stdlib-write-docs.lithia"
-            ],
-            "cwd": "${workspaceFolder}",
-            "env": {
-                "LITHIA_STDLIB": "${workspaceFolder}/stdlib"
-            }
-        },
-        {
-            "name": "Test example stdlib",
-            "type": "go",
-            "request": "launch",
-            "mode": "auto",
-            "program": "${workspaceFolder}/cmd/lithia/main.go",
-            "args": [
-                "${workspaceFolder}/stdlib/stdlib-tests.lithia"
-            ],
-            "env": {
-                "LITHIA_TESTS": "1",
-                "LITHIA_STDLIB": "${workspaceFolder}/stdlib"
-            }
-        },
-        {
-            "name": "Launch lithia",
-            "type": "go",
-            "request": "launch",
-            "mode": "auto",
-            "program": "${workspaceFolder}/cmd/lithia/main.go",
-            "args": [
-                "${workspaceFolder}/examples/syntax.lithia"
-            ],
-            "env": {
-                "LITHIA_STDLIB": "${workspaceFolder}/stdlib"
-            }
-        },
-    ]
-}
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Write docs",
+      "type": "go",
+      "request": "launch",
+      "mode": "auto",
+      "program": "${workspaceFolder}/cmd/lithia/main.go",
+      "args": ["${workspaceFolder}/stdlib/stdlib-write-docs.lithia"],
+      "cwd": "${workspaceFolder}",
+      "env": {
+        "LITHIA_STDLIB": "${workspaceFolder}/stdlib"
+      }
+    },
+    {
+      "name": "Test example stdlib",
+      "type": "go",
+      "request": "launch",
+      "mode": "auto",
+      "program": "${workspaceFolder}/cmd/lithia/main.go",
+      "args": ["${workspaceFolder}/stdlib/stdlib-tests.lithia"],
+      "cwd": "${workspaceFolder}",
+      "env": {
+        "LITHIA_TESTS": "1",
+        "LITHIA_STDLIB": "${workspaceFolder}/stdlib"
+      }
+    },
+    {
+      "name": "Launch lithia",
+      "type": "go",
+      "request": "launch",
+      "mode": "auto",
+      "program": "${workspaceFolder}/cmd/lithia/main.go",
+      "args": ["${workspaceFolder}/examples/fib-type.lithia"],
+      "cwd": "${workspaceFolder}",
+      "env": {
+        "LITHIA_STDLIB": "${workspaceFolder}/stdlib"
+      }
+    }
+  ]
+}

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## unreleased
+
+- stdlib: added `arity` to `prelude.Function`
+- compiler: massive performance improvements
+- compiler: large refactoring
+- fix: rare equality bugs
+
 ## v0.0.9
 
 - fix: `==` didn't work for independent values

README.md

@@ -166,9 +166,9 @@ func greet { person =>
 
 in Lithia are different than you might know them from other languages.
 Other languages define enums as a list of constant values. A few allow associated values for each named case.
-A Lithia *enum* is an enumeration of types.
+A Lithia _enum_ is an enumeration of types.
 
-There is syntactic sugar for value enumerations, to directly declare a case and the associated *enum* or *data* type.
+There is syntactic sugar for value enumerations, to directly declare a case and the associated _enum_ or _data_ type.
 
 ```
 enum JuristicPerson {
@@ -407,7 +407,7 @@ Most languages allow type casts and checks. Lithia does only support the type sw
 
 These checks are unstructured and therefore tempt to be used in the wrong places. Though type checks should be used sparingly. Lithia prefers to move required decisions to the edge of the code. Witnesses should implement decisions for the provided data and desired behavior.
 
-If there is one type to focus on, the tooling and the developer can understand all cases much easier and faster.
+If there is one type to focus on, the developer and the tooling can understand all cases much easier and faster.
 
 ## License
 

ast/context-file.go

@@ -0,0 +1,40 @@
+package ast
+
+type SourceFile struct {
+	Path         string
+	Imports      []ModuleName
+	Declarations []Decl
+	Statements   []Expr
+
+	*Source
+}
+
+func MakeSourceFile(
+	Path string,
+	Source *Source,
+) *SourceFile {
+	return &SourceFile{
+		Path:         Path,
+		Source:       Source,
+		Imports:      make([]ModuleName, 0),
+		Declarations: make([]Decl, 0),
+		Statements:   make([]Expr, 0),
+	}
+}
+
+func (sf *SourceFile) AddDecl(decl Decl) {
+	if decl == nil {
+		return
+	}
+	if importDecl, ok := decl.(DeclImport); ok {
+		sf.Imports = append(sf.Imports, importDecl.ModuleName)
+	}
+	sf.Declarations = append(sf.Declarations, decl)
+}
+
+func (sf *SourceFile) AddExpr(expr Expr) {
+	if expr == nil {
+		return
+	}
+	sf.Statements = append(sf.Statements, expr)
+}

ast/context-module.go

@@ -0,0 +1,20 @@
+package ast
+
+type ModuleName string
+
+type ContextModule struct {
+	Name ModuleName
+
+	Files []*SourceFile
+}
+
+func MakeContextModule(name ModuleName) *ContextModule {
+	return &ContextModule{
+		Name:  name,
+		Files: []*SourceFile{},
+	}
+}
+
+func (m *ContextModule) AddSourceFile(sourceFile *SourceFile) {
+	m.Files = append(m.Files, sourceFile)
+}

ast/decl-constant.go

@@ -0,0 +1,31 @@
+package ast
+
+var _ Decl = DeclConstant{}
+
+type DeclConstant struct {
+	Name  Identifier
+	Value Expr
+
+	Docs     *Docs
+	MetaInfo *MetaDecl
+}
+
+func (e DeclConstant) DeclName() Identifier {
+	return e.Name
+}
+
+func (e DeclConstant) Meta() *MetaDecl {
+	return e.MetaInfo
+}
+
+func (e DeclConstant) IsExportedDecl() bool {
+	return true
+}
+
+func MakeDeclConstant(name Identifier, value Expr, source *Source) *DeclConstant {
+	return &DeclConstant{
+		Name:     name,
+		Value:    value,
+		MetaInfo: &MetaDecl{source},
+	}
+}

ast/decl-data.go

@@ -0,0 +1,38 @@
+package ast
+
+var _ Decl = DeclData{}
+
+type DeclData struct {
+	Name   Identifier
+	Fields []DeclField
+
+	Docs     *Docs
+	MetaInfo *MetaDecl
+}
+
+func (e DeclData) DeclName() Identifier {
+	return e.Name
+}
+
+func (e DeclData) Meta() *MetaDecl {
+	return e.MetaInfo
+}
+
+func (e DeclData) IsExportedDecl() bool {
+	return true
+}
+
+func MakeDeclData(name Identifier, source *Source) *DeclData {
+	return &DeclData{
+		Name:   name,
+		Fields: []DeclField{},
+		Docs:   MakeDocs([]string{}),
+		MetaInfo: &MetaDecl{
+			Source: source,
+		},
+	}
+}
+
+func (e *DeclData) AddField(field DeclField) {
+	e.Fields = append(e.Fields, field)
+}

ast/decl-enum-case.go

@@ -0,0 +1,29 @@
+package ast
+
+var _ Decl = DeclEnumCase{}
+
+type DeclEnumCase struct {
+	Name Identifier
+
+	Docs     *Docs
+	MetaInfo *MetaDecl
+}
+
+func (e DeclEnumCase) DeclName() Identifier {
+	return e.Name
+}
+
+func (e DeclEnumCase) Meta() *MetaDecl {
+	return e.MetaInfo
+}
+
+func (e DeclEnumCase) IsExportedDecl() bool {
+	return true
+}
+
+func MakeDeclEnumCase(name Identifier) *DeclEnumCase {
+	return &DeclEnumCase{
+		Name:     name,
+		MetaInfo: &MetaDecl{},
+	}
+}

ast/decl-enum.go

@@ -0,0 +1,52 @@
+package ast
+
+import "fmt"
+
+var _ Decl = DeclEnum{}
+
+type DeclEnum struct {
+	Name  Identifier
+	Cases []*DeclEnumCase
+
+	Docs     *Docs
+	MetaInfo *MetaDecl
+}
+
+func (e DeclEnum) DeclName() Identifier {
+	return e.Name
+}
+
+func (e DeclEnum) Meta() *MetaDecl {
+	return e.MetaInfo
+}
+
+func (e DeclEnum) IsExportedDecl() bool {
+	return true
+}
+
+func MakeDeclEnum(name Identifier, source *Source) *DeclEnum {
+	return &DeclEnum{
+		Name:  name,
+		Cases: []*DeclEnumCase{},
+		Docs:  MakeDocs([]string{}),
+		MetaInfo: &MetaDecl{
+			Source: source,
+		},
+	}
+}
+
+func (e *DeclEnum) AddCase(case_ *DeclEnumCase) {
+	e.Cases = append(e.Cases, case_)
+}
+
+func (e DeclEnum) String() string {
+	declarationClause := fmt.Sprintf("enum %s", e.Name)
+	if len(e.Cases) == 0 {
+		return declarationClause
+	}
+	declarationClause += " { "
+	for _, caseDecl := range e.Cases {
+		declarationClause += string(caseDecl.Name) + "; "
+	}
+	return declarationClause + "}"
+}

ast/decl-extern-func.go

@@ -0,0 +1,30 @@
+package ast
+
+var _ Decl = DeclExternFunc{}
+
+type DeclExternFunc struct {
+	Name       Identifier
+	Parameters []DeclParameter
+
+	MetaInfo *MetaDecl
+}
+
+func (e DeclExternFunc) DeclName() Identifier {
+	return e.Name
+}
+
+func (e DeclExternFunc) Meta() *MetaDecl {
+	return e.MetaInfo
+}
+
+func (e DeclExternFunc) IsExportedDecl() bool {
+	return true
+}
+
+func MakeDeclExternFunc(name Identifier, params []DeclParameter, source *Source) *DeclExternFunc {
+	return &DeclExternFunc{
+		Name:       name,
+		Parameters: params,
+		MetaInfo:   &MetaDecl{source},
+	}
+}