Custom types (#47)

* Slightly improve error and context handling

* Move default value evaluation to separate function

* Replace tabs by spaces

* Start struct definition implementation

* Start preparation for custom defined types
(#45)

* Implement first working draft of type declarations/definitions (slices not yet supported) (#45)

* Do some renaming (#45)

* Do some renaming (#45)

* Fix type definition base type handling (#45)

* Add tests (#45)

* Revert "Start struct definition implementation"

This reverts commit c81e3c8.

* Fix typo (#45)

* Start constants implementation (#41)

* Use a common function for variable and constant evaluation (evaluateNamedValueDefinition) (#41)

* Improve error message handling

* Add first working draft of single line const definition (#41)

* Fix Const instantiation (#41)

* Define in Expression if it's constant to be able to decide if the assigned value to a constant is actually constant (#41)

* Fix expression evaluation (#41)

* Make sure values are assigned at constant definition (#41)

* Make sure value cannot be assigned to named value if it's a constant (#41)

* Add tests (#41)

* Allow constant and variable definitions via grouping syntax (#41)

* Add simple iota implementation (only simple increment for now) (#41)

* Add tests (#41)

* Update README (#41)

* Fix typo

Author: monstermichl

README.md

@@ -30,20 +30,44 @@ Supported variable types are *bool*, *int*, *string* and *error*.
 ```golang
 // Variable definition with default value.
 var a int
-var a, b int
+var b, c int
 ```
 
 ```golang
 // Variable definition with assigned value.
 var a int = 5
-var a, b int = divisionWithRemainder(5, 2)
+var b, c int = divisionWithRemainder(5, 2)
+```
+
+```golang
+// Variable definition via grouping.
+var (
+    a = 5
+    b, c int = divisionWithRemainder(5, 2)
+)
 ```
 
 ```golang
 // Variable definition short form.
 a := 5
-a, b := 5, 6
-a, b := divisionWithRemainder(5, 2)
+b, c := 5, 6
+d, e := divisionWithRemainder(5, 2)
+```
+
+### Constants
+```golang
+// Constant definition.
+const a = 0
+const b, c = 1, 2
+```
+
+```golang
+// Constant definition via grouping.
+const (
+    a = -1
+    b = iota
+    c
+)
 ```
 
 ### Control flow
@@ -196,6 +220,25 @@ import (
 print(strings.Contains("Hello World", "World")) // Prints 1.
 ```
 
+### Type declarations
+TypeShell supports the declaration of types. However, types which result in slices are not supported yet.
+
+```golang
+// Define a type.
+type myType int
+
+var a myType
+a = myType(24)
+```
+
+```golang
+// Define an alias.
+type myType = int
+
+var a myType
+a = 24
+```
+
 ### Builtin
 ```golang
 // Returns the length of a slice or a string.

lexer/lexer.go

@@ -42,9 +42,6 @@ const (
 	STRING_LITERAL
 	NIL_LITERAL
 
-	// Types.
-	DATA_TYPE
-
 	// Separators.
 	COMMA
 	COLON
@@ -58,6 +55,8 @@ const (
 
 	// Keywords.
 	IMPORT
+	TYPE_DECLARATION
+	CONST_DEFINITION
 	VAR_DEFINITION
 	FUNCTION_DEFINITION
 	RETURN
@@ -70,6 +69,7 @@ const (
 	RANGE
 	BREAK
 	CONTINUE
+	IOTA
 
 	// Builtin functions.
 	LEN
@@ -90,13 +90,6 @@ const (
 	EOF
 )
 
-const (
-	DATA_TYPE_BOOLEAN VarType = "bool"
-	DATA_TYPE_INTEGER VarType = "int"
-	DATA_TYPE_STRING  VarType = "string"
-	DATA_TYPE_ERROR   VarType = "error"
-)
-
 type Token struct {
 	tokenType TokenType
 	value     string
@@ -180,6 +173,8 @@ var nonAlphabeticTokens = []tokenMapping{
 var keywords = map[string]TokenType{
 	// Common keywords.
 	"import":   IMPORT,
+	"type":     TYPE_DECLARATION,
+	"const":    CONST_DEFINITION,
 	"var":      VAR_DEFINITION,
 	"func":     FUNCTION_DEFINITION,
 	"return":   RETURN,
@@ -192,6 +187,7 @@ var keywords = map[string]TokenType{
 	"range":    RANGE,
 	"break":    BREAK,
 	"continue": CONTINUE,
+	"iota":     IOTA,
 	"nil":      NIL_LITERAL,
 
 	// Builtin functions.
@@ -204,12 +200,6 @@ var keywords = map[string]TokenType{
 	"read":   READ,
 	"write":  WRITE,
 	"panic":  PANIC,
-
-	// Types.
-	DATA_TYPE_BOOLEAN: DATA_TYPE,
-	DATA_TYPE_INTEGER: DATA_TYPE,
-	DATA_TYPE_STRING:  DATA_TYPE,
-	DATA_TYPE_ERROR:   DATA_TYPE,
 }
 
 func newToken(value string, tokenType TokenType, row int, column int) Token {

parser/appcall.go

@@ -14,6 +14,10 @@ func (a AppCall) ValueType() ValueType {
 	return NewValueType(DATA_TYPE_MULTIPLE, false)
 }
 
+func (a AppCall) IsConstant() bool {
+	return false
+}
+
 func (a AppCall) Name() string {
 	return a.name
 }

parser/assignment.go

@@ -0,0 +1,6 @@
+package parser
+
+type Assignment interface {
+	Statement
+	AssignmentType() AssignmentType
+}

parser/binaryoperation.go

@@ -1,9 +1,9 @@
 package parser
 
 type BinaryOperation struct {
-	left      Expression
-	operator  BinaryOperator
-	right     Expression
+	left     Expression
+	operator BinaryOperator
+	right    Expression
 }
 
 func (b BinaryOperation) StatementType() StatementType {
@@ -14,6 +14,10 @@ func (b BinaryOperation) ValueType() ValueType {
 	return b.left.ValueType()
 }
 
+func (b BinaryOperation) IsConstant() bool {
+	return b.Left().IsConstant() && b.Right().IsConstant()
+}
+
 func (b BinaryOperation) Left() Expression {
 	return b.left
 }

parser/comparison.go

@@ -22,6 +22,10 @@ func (c Comparison) ValueType() ValueType {
 	return ValueType{dataType: DATA_TYPE_BOOLEAN}
 }
 
+func (c Comparison) IsConstant() bool {
+	return c.Left().IsConstant() && c.Right().IsConstant()
+}
+
 func (c Comparison) Left() Expression {
 	return c.left
 }

parser/const.go

@@ -0,0 +1,70 @@
+package parser
+
+type Const struct {
+	name      string
+	valueType ValueType
+	global    bool
+	public    bool
+}
+
+func NewConst(name string, valueType ValueType, global bool, public bool) Const {
+	return Const{
+		name,
+		valueType,
+		global,
+		public,
+	}
+}
+
+func (c Const) Name() string {
+	return c.name
+}
+
+func (c Const) ValueType() ValueType {
+	return c.valueType
+}
+
+func (c Const) IsConstant() bool {
+	return true
+}
+
+func (c *Const) SetValueType(valueType ValueType) {
+	c.valueType = valueType
+}
+
+func (c Const) Global() bool {
+	return c.global
+}
+
+func (c Const) Public() bool {
+	return c.public
+}
+
+type ConstDefinition struct {
+	constants []Const
+	values    []Expression
+}
+
+func (c ConstDefinition) StatementType() StatementType {
+	return STATEMENT_TYPE_CONST_DEFINITION
+}
+
+func (c ConstDefinition) AssignmentType() AssignmentType {
+	return ASSIGNMENT_TYPE_VALUE
+}
+
+func (c ConstDefinition) Constants() []Const {
+	return c.constants
+}
+
+func (c ConstDefinition) Values() []Expression {
+	return c.values
+}
+
+type ConstEvaluation struct {
+	Const
+}
+
+func (c ConstEvaluation) StatementType() StatementType {
+	return STATEMENT_TYPE_CONST_EVALUATION
+}

parser/copy.go

@@ -13,6 +13,10 @@ func (c Copy) ValueType() ValueType {
 	return NewValueType(DATA_TYPE_INTEGER, false)
 }
 
+func (c Copy) IsConstant() bool {
+	return false
+}
+
 func (c Copy) Source() Expression {
 	return c.source
 }

parser/exists.go

@@ -12,6 +12,10 @@ func (e Exists) ValueType() ValueType {
 	return NewValueType(DATA_TYPE_BOOLEAN, false)
 }
 
+func (e Exists) IsConstant() bool {
+	return false
+}
+
 func (e Exists) Path() Expression {
 	return e.path
 }

parser/expression.go

@@ -4,4 +4,5 @@ type Expression interface {
 	// An expression is a super-type of statement which results in a value.
 	Statement
 	ValueType() ValueType
+	IsConstant() bool
 }