fix: check types exist #74

Author: JohnCoene

environment/environment.go

@@ -223,6 +223,7 @@ func makeTypeKey(pkg, name string) string {
 }
 
 func (e *Environment) GetType(pkg, name string) (Type, bool) {
+	e.LoadPackageTypes(pkg)
 	obj, ok := e.types[makeTypeKey(pkg, name)]
 	if !ok && e.outer != nil {
 		obj, ok = e.outer.GetType(pkg, name)

walker/types.go

@@ -13,6 +13,25 @@ type Function struct {
 	arguments  []ast.Types
 }
 
+func (w *Walker) typesExist(types ast.Types) (*ast.Type, bool) {
+	for _, t := range types {
+		// bit hacky but NA, NULL, etc. have a blank type
+		// need to fix upstream in parser
+		if t.Name == "" {
+			return nil, true
+		}
+
+		_, te := w.env.GetType(t.Package, t.Name)
+		_, fe := w.env.GetSignature(t.Name)
+
+		if !te && !fe {
+			return t, false
+		}
+	}
+
+	return nil, true
+}
+
 func (w *Walker) allTypesIdentical(types []*ast.Type) bool {
 	if len(types) == 0 {
 		return true

walker/walk.go

@@ -300,7 +300,19 @@ func (w *Walker) walkKnownCallTypeFactorExpression(node *ast.CallExpression, t e
 	for _, v := range node.Arguments {
 		at, _ := w.Walk(v.Value)
 		w.checkIfIdentifier(v.Value)
-		ok := w.typesValid(t.Type, at)
+
+		missingType, ok := w.typesExist(t.Type)
+
+		if !ok {
+			w.addFatalf(
+				node.Token,
+				"type `%v` is not declared",
+				missingType,
+			)
+			continue
+		}
+
+		ok = w.typesValid(t.Type, at)
 
 		if !ok {
 			w.addFatalf(
@@ -329,7 +341,18 @@ func (w *Walker) walkKnownCallTypeVectorExpression(node *ast.CallExpression, t e
 	for _, v := range node.Arguments {
 		at, _ := w.Walk(v.Value)
 		w.checkIfIdentifier(v.Value)
-		ok := w.typesValid(t.Type, at)
+		missingType, ok := w.typesExist(t.Type)
+
+		if !ok {
+			w.addFatalf(
+				node.Token,
+				"type `%v` is not declared",
+				missingType,
+			)
+			continue
+		}
+
+		ok = w.typesValid(t.Type, at)
 
 		if !ok {
 			w.addFatalf(
@@ -357,7 +380,18 @@ func (w *Walker) walkKnownCallTypeVectorExpression(node *ast.CallExpression, t e
 func (w *Walker) walkKnownCallTypeListExpression(node *ast.CallExpression, t environment.Type) (ast.Types, ast.Node) {
 	for _, v := range node.Arguments {
 		at, _ := w.Walk(v.Value)
-		ok := w.typesValid(t.Type, at)
+		missingType, ok := w.typesExist(at)
+
+		if !ok {
+			w.addFatalf(
+				node.Token,
+				"type `%v` is not declared",
+				missingType,
+			)
+			continue
+		}
+
+		ok = w.typesValid(t.Type, at)
 
 		if !ok {
 			w.addFatalf(
@@ -403,7 +437,18 @@ func (w *Walker) walkKnownCallTypeStructExpression(node *ast.CallExpression, t e
 		}
 
 		if i == 0 {
-			ok := w.typesValid(t.Type, at)
+			missingType, ok := w.typesExist(t.Type)
+
+			if !ok {
+				w.addFatalf(
+					node.Token,
+					"type `%v` is not declared",
+					missingType,
+				)
+				continue
+			}
+
+			ok = w.typesValid(t.Type, at)
 			if !ok {
 				w.addFatalf(
 					node.Token,
@@ -561,6 +606,17 @@ func (w *Walker) walkKnownCallExpression(node *ast.CallExpression, fn *ast.Funct
 			param, _ = getFunctionElipsis(fn.Parameters)
 		}
 
+		missingType, ok := w.typesExist(param.Type)
+
+		if !ok {
+			w.addFatalf(
+				param.Token,
+				"type `%v` is not declared",
+				missingType,
+			)
+			continue
+		}
+
 		ok = w.typesValid(param.Type, argumentType)
 
 		if !ok && argument.Name == "" {
@@ -1054,7 +1110,19 @@ func (w *Walker) walkInfixExpressionEqual(node *ast.InfixExpression) (ast.Types,
 	}
 
 	rt, rn := w.Walk(node.Right)
-	ok := w.typesValid(lt, rt)
+	missingType, ok := w.typesExist(rt)
+
+	if !ok {
+		w.addFatalf(
+			rn.Item(),
+			"type `%v` is not declared",
+			missingType,
+		)
+
+		return rt, rn
+	}
+
+	ok = w.typesValid(lt, rt)
 	if !ok {
 		w.addFatalf(
 			node.Token,
@@ -1115,7 +1183,28 @@ func (w *Walker) walkLetStatement(node *ast.LetStatement) (ast.Types, ast.Node)
 		},
 	)
 
+	t, ok := w.typesExist(node.Type)
+
+	if !ok {
+		w.addFatalf(
+			node.Token,
+			"type `%v` is not declared",
+			t,
+		)
+	}
+
 	rt, rn := w.Walk(node.Value)
+	missingType, ok := w.typesExist(rt)
+
+	if !ok {
+		w.addFatalf(
+			rn.Item(),
+			"type `%v` is not declared",
+			missingType,
+		)
+		return rt, rn
+	}
+
 	ok = w.typesValid(node.Type, rt)
 
 	if !ok {
@@ -1177,7 +1266,18 @@ func (w *Walker) walkReturnStatement(node *ast.ReturnStatement) (ast.Types, ast.
 	w.checkIfIdentifier(n)
 
 	if w.env.ReturnType() != nil {
-		ok := w.typesValid(w.env.ReturnType(), t)
+		missingType, ok := w.typesExist(w.env.ReturnType())
+
+		if !ok {
+			w.addFatalf(
+				node.Token,
+				"type `%v` is not declared",
+				missingType,
+			)
+			return t, node
+		}
+
+		ok = w.typesValid(w.env.ReturnType(), t)
 		if !ok {
 			w.addFatalf(
 				node.Token,

walker/walk_test.go

@@ -509,7 +509,7 @@ func (p: any) meth(): null {}
 }
 
 func TestBasic(t *testing.T) {
-	code := `let x: int | na = 1
+	code := `let x: int = 1
 
 x = 2
 
@@ -1216,17 +1216,14 @@ func TestEnvironment(t *testing.T) {
 	code := `
 let z: int = 1
 
-func addz(n: int = 1, y: int = 2): int | na {
+func addz(n: int = 1, y: int = 2): int {
 	if(n == 1){
 		return NA
 	}
 
 	return n + y + z
 }
 
-# should fail, this can be na
-let result: int = addz(1, 2)
-
 # should fail, comparing wrong types
 if (1 == "hello") {
   print("1")
@@ -1256,7 +1253,6 @@ print(c)
 	w.Run(prog)
 
 	expected := diagnostics.Diagnostics{
-		{Severity: diagnostics.Fatal},
 		{Severity: diagnostics.Info},
 		{Severity: diagnostics.Fatal},
 	}
@@ -1356,3 +1352,31 @@ e(x = true)
 
 	w.testDiagnostics(t, expected)
 }
+
+func TestSymbols(t *testing.T) {
+	code := `
+# should fail, type does not exist
+let foo: bar = baz
+
+# should fail, baz not found
+foo = baz`
+
+	l := lexer.NewTest(code)
+
+	l.Run()
+	p := parser.New(l)
+
+	prog := p.Run()
+
+	environment.SetLibrary(r.LibPath())
+	w := New()
+
+	w.Run(prog)
+
+	expected := diagnostics.Diagnostics{
+		{Severity: diagnostics.Fatal},
+		{Severity: diagnostics.Warn},
+	}
+
+	w.testDiagnostics(t, expected)
+}