Merged origin/dev into dev

Author: bafto

src/ddperror/codes.go

@@ -57,6 +57,7 @@ const (
 	SEM_GENERIC_FUNCTION_BODY_UNDEFINED                         // a generic function was declared without a definition
 	SEM_ERROR_INSTANTIATING_GENERIC_FUNCTION                    // an error occured while instantiating a generic function
 	SEM_CANNOT_INSTANTIATE_NON_GENERIC_TYPE                     // a non-generic type was given with type parameters
+	SEM_UNABLE_TO_UNIFY_FIELD_TYPES                             // for a generic struct alias not all typeparamters could be unified
 )
 
 // type error codes

src/parser/declarations.go

@@ -906,12 +906,19 @@ func (p *parser) validateStructAlias(aliasTokens []token.Token, fields []*ast.Va
 
 	nameTypeMap := make(map[string]ddptypes.ParameterType, len(fields)) // map that holds the parameter names contained in the alias and their corresponding type
 	args := make(map[string]ddptypes.Type, len(fields))                 // the arguments of the alias
+	genericUnifiedMap := make(map[string]bool, len(fields)*2)           // holds wether a generic type is unified
 	for _, v := range fields {
 		nameTypeMap[v.Name()] = ddptypes.ParameterType{
 			Type:        v.Type,
 			IsReference: false, // fields are never references
 		}
 		args[v.Name()] = v.Type
+		genericTypes, _ := ddptypes.CastDeeplyNestedGenerics(v.Type)
+		for _, typ := range genericTypes {
+			if _, ok := genericUnifiedMap[typ.Name]; !ok {
+				genericUnifiedMap[typ.Name] = v.InitVal != nil
+			}
+		}
 	}
 	// validate that each parameter is contained in the alias once at max
 	// and fill in the AliasInfo
@@ -932,6 +939,12 @@ func (p *parser) validateStructAlias(aliasTokens []token.Token, fields []*ast.Va
 
 		if argTyp, ok := nameTypeMap[k]; ok {
 			aliasTokens[i].AliasInfo = &argTyp
+
+			genericTypes, _ := ddptypes.CastDeeplyNestedGenerics(argTyp.Type)
+			for _, typ := range genericTypes {
+				genericUnifiedMap[typ.Name] = true
+			}
+
 			delete(nameTypeMap, k)
 		} else {
 			err := ddperror.New(ddperror.SEM_ALIAS_BAD_ARGS, ddperror.LEVEL_ERROR,
@@ -942,6 +955,17 @@ func (p *parser) validateStructAlias(aliasTokens []token.Token, fields []*ast.Va
 			return &err, nil
 		}
 	}
+
+	for typ, wasUnified := range genericUnifiedMap {
+		if !wasUnified {
+			err := ddperror.New(ddperror.SEM_UNABLE_TO_UNIFY_FIELD_TYPES, ddperror.LEVEL_ERROR,
+				token.NewRange(&aliasTokens[len(aliasTokens)-1], &aliasTokens[len(aliasTokens)-1]),
+				fmt.Sprintf("Der generische Typ %s konnte nicht unifiziert werden", typ),
+				p.module.FileName,
+			)
+			return &err, nil
+		}
+	}
 	return nil, args
 }
 

src/parser/declarations_test.go

@@ -602,8 +602,7 @@ Wir nennen die generische Kombination aus
 	dem T y,
 	dem R z,
 	der R Liste l,
-eine Struktur, und erstellen sie so:
-	"Struktur"
+eine Struktur."
 		`),
 	})
 
@@ -614,3 +613,60 @@ eine Struktur, und erstellen sie so:
 	assert.IsType(&ddptypes.GenericStructType{}, decl.Type)
 	assert.Equal([]ddptypes.GenericType{{Name: "T"}, {Name: "R"}}, decl.Type.(*ddptypes.GenericStructType).GenericTypes)
 }
+
+func TestValidateStructAlias(t *testing.T) {
+	assert := assert.New(t)
+
+	given := createParser(t, parser{})
+
+	alias := scanAlias(t, `foo <a> <b>`, map[string]ddptypes.ParameterType{
+		"a": {Type: ddptypes.ZAHL},
+		"b": {Type: ddptypes.ZAHL},
+	})
+	err, _ := given.validateStructAlias(alias.GetTokens(), []*ast.VarDecl{
+		{NameTok: token.Token{Literal: "a"}, Type: ddptypes.ZAHL},
+		{NameTok: token.Token{Literal: "b"}, Type: ddptypes.ZAHL},
+	})
+	assert.Nil(err)
+
+	alias = scanAlias(t, `foo <a>`, map[string]ddptypes.ParameterType{
+		"a": {Type: ddptypes.ZAHL},
+		"b": {Type: ddptypes.ZAHL},
+	})
+	err, _ = given.validateStructAlias(alias.GetTokens(), []*ast.VarDecl{
+		{NameTok: token.Token{Literal: "a"}, Type: ddptypes.ZAHL},
+		{NameTok: token.Token{Literal: "b"}, Type: ddptypes.ZAHL},
+	})
+	assert.Nil(err)
+
+	alias = scanAlias(t, `foo <a> <b>`, map[string]ddptypes.ParameterType{
+		"a": {Type: ddptypes.GenericType{Name: "T"}},
+		"b": {Type: ddptypes.GenericType{Name: "R"}},
+	})
+	err, _ = given.validateStructAlias(alias.GetTokens(), []*ast.VarDecl{
+		{NameTok: token.Token{Literal: "a"}, Type: ddptypes.GenericType{Name: "T"}},
+		{NameTok: token.Token{Literal: "b"}, Type: ddptypes.GenericType{Name: "R"}},
+	})
+	assert.Nil(err)
+
+	alias = scanAlias(t, `foo <a>`, map[string]ddptypes.ParameterType{
+		"a": {Type: ddptypes.GenericType{Name: "T"}},
+		"b": {Type: ddptypes.GenericType{Name: "R"}},
+	})
+	err, _ = given.validateStructAlias(alias.GetTokens(), []*ast.VarDecl{
+		{NameTok: token.Token{Literal: "a"}, Type: ddptypes.GenericType{Name: "T"}},
+		{NameTok: token.Token{Literal: "b"}, Type: ddptypes.GenericType{Name: "R"}},
+	})
+	assert.NotNil(err)
+	assert.Equal(ddperror.SEM_UNABLE_TO_UNIFY_FIELD_TYPES, err.Code)
+
+	alias = scanAlias(t, `foo <a>`, map[string]ddptypes.ParameterType{
+		"a": {Type: ddptypes.GenericType{Name: "T"}},
+		"b": {Type: ddptypes.GenericType{Name: "R"}},
+	})
+	err, _ = given.validateStructAlias(alias.GetTokens(), []*ast.VarDecl{
+		{NameTok: token.Token{Literal: "a"}, Type: ddptypes.GenericType{Name: "T"}},
+		{NameTok: token.Token{Literal: "b"}, Type: ddptypes.GenericType{Name: "R"}, InitVal: &ast.IntLit{}},
+	})
+	assert.Nil(err)
+}