Created basic test for parser

parser/parser.go

@@ -11,18 +11,25 @@ type ParsingOperation struct {
 	token      lexer.Token
 	tokens     []lexer.Token
 	tokenIndex int
+
+	tree *SyntaxTree
 }
 
 // Parse reads the files located in the module specified by modulePath, and
 // converts them into an abstract syntax tree.
 func Parse (modulePath string) (tree *SyntaxTree, err error) {
 	parser := ParsingOperation { modulePath: modulePath }
-	tree, err = parser.parse()
+	err  = parser.parse()
+	tree = parser.tree
 	return
 }
 
 // parse runs the parsing operation.
-func (parser *ParsingOperation) parse () (tree *SyntaxTree, err error) {
+func (parser *ParsingOperation) parse () (err error) {
+	if parser.tree == nil {
+		parser.tree = &SyntaxTree { }
+	}
+
 	if parser.modulePath[len(parser.modulePath) - 1] != '/' {
 		parser.modulePath += "/"
 	}

parser/parser_test.go

@@ -0,0 +1,33 @@
+package parser
+
+import "reflect"
+import "testing"
+
+func checkTree (modulePath string, correct *SyntaxTree, test *testing.T) {
+	tree, err := Parse(modulePath)
+	
+	if err != nil {
+		test.Log("returned error:")
+		test.Log(err.Error())
+		test.Fail()
+		return
+	}
+
+	if !reflect.DeepEqual(tree, correct) {
+		test.Log("trees not equal")
+		test.Fail()
+		return
+	}
+}
+
+func TestMeta (test *testing.T) {
+	checkTree("../tests/parser/meta",&SyntaxTree {
+		license: "GPLv3",
+		author:  "Sasha Koshka",
+	
+		requires: []string {
+			"someModule",
+			"otherModule",
+		},
+	}, test)
+}

parser/tree.go

@@ -4,5 +4,8 @@ package parser
 // can be expected to be syntactically correct, but it might not be semantically
 // correct (because it has not been analyzed yet.)
 type SyntaxTree struct {
-	
+	license string
+	author  string
+
+	requires []string
 }

tests/parser/full/main.arf

@@ -0,0 +1,41 @@
+:arf
+author "Sasha Koshka"
+license "GPLv3"
+require "io"
+---
+
+# this is a global variable
+data wn helloText:String "Hello, world!"
+
+# this is a struct definition
+type rr Greeter:Obj
+        # "Hi." is a string constant. all Greeters will be initialized with a
+        # pointer to it. I don't know really it depends on what I decide that
+        # a String type even is.
+        wr text:String "Hi."
+                "sdfdsf" "ahh"
+                "asdf"
+
+# this is a function
+func rr main
+        > argc:Int
+        > argv:{String}
+        < status:Int 0
+        ---
+        let greeter:Greeter:mut
+        greeter.setText helloText
+        greeter.greet
+
+# this is a member function
+func rr greet
+        @ greeter:{Greeter}
+        ---
+        io.println greeter.text
+
+# this is mutator member function
+func rr setText
+        @ greeter:{Greeter}
+        > text:String
+        ---
+        greeter.text.set text
+

tests/parser/meta/meta.arf

@@ -0,0 +1,6 @@
+:arf
+author "Sasha Koshka"
+license "GPLv3"
+require "someModule"
+require "otherModule"
+---