semantic: Implement simple global union literals to implement .init.

Author: bhelyer

src/volt/lowerer/llvmlowerer.d

@@ -749,7 +749,7 @@ void lowerStructLiteral(LanguagePass lp, ir.Scope current, ref ir.Exp exp, ir.St
 	panicAssert(exp, literal.type !is null);
 	auto theStruct = cast(ir.Struct) realType(literal.type);
 	panicAssert(exp, theStruct !is null);
-	auto fields = getStructFieldVars(theStruct);
+	auto fields = getAggregateFieldVars(theStruct);
 	// The extyper should've caught this.
 	panicAssert(exp, fields.length >= literal.exps.length);
 

src/volt/semantic/classify.d

@@ -1290,7 +1290,7 @@ ir.Type[] getStructFieldTypes(ir.Struct _struct)
 }
 
 //! Retrieves the Variables in _struct, in the order they appear.
-ir.Variable[] getStructFieldVars(ir.Struct _struct)
+ir.Variable[] getAggregateFieldVars(ir.Aggregate _struct)
 {
 	ir.Variable[] vars;
 

src/volt/semantic/extyper.d

@@ -5151,16 +5151,31 @@ void tagLiteralType(ir.Exp exp, ir.Type type)
 		auto stype = cast(ir.Struct)realType(type);
 		auto slit = cast(ir.StructLiteral)exp;
 		if (stype is null || slit is null) {
-			throw panic(/*#ref*/exp.loc, "tagging struct literal as not an struct.");
+			throw panic(/*#ref*/exp.loc, "tagging struct literal as not a struct.");
 		}
-		auto vars = getStructFieldVars(stype);
+		auto vars = getAggregateFieldVars(stype);
 		if (slit.exps.length > vars.length) {
 			throw makeWrongNumberOfArgumentsToStructLiteral(/*#ref*/exp.loc);
 		}
 		foreach (i, val; slit.exps) {
 			tagLiteralType(val, vars[i].type);
 		}
 		break;
+	case UnionLiteral:
+		auto utype = cast(ir.Union)realType(type);
+		auto ulit = exp.toUnionLiteralFast();
+		if (utype is null || ulit is null) {
+			throw panic(/*#ref*/exp.loc, "tagging union literal as not a union");
+		}
+		auto vars = getAggregateFieldVars(utype);
+		if (ulit.exps.length > vars.length) {
+			// @TODO: Union literals that can just take the largest field.
+			throw makeWrongNumberOfArgumentsToStructLiteral(/*#ref*/exp.loc);
+		}
+		foreach (i, val; ulit.exps) {
+			tagLiteralType(val, vars[i].type);
+		}
+		break;
 	default:
 		throw panicUnhandled(/*#ref*/exp.loc, "literal type");
 	}

src/volt/semantic/typer.d

@@ -100,6 +100,9 @@ ir.Type getExpTypeImpl(ir.Exp exp)
 		auto asStructLiteral = cast(ir.StructLiteral) exp;
 		assert(asStructLiteral !is null);
 		return getStructLiteralType(asStructLiteral);
+	case UnionLiteral:
+		auto asUnionLiteral = exp.toUnionLiteralFast();
+		return getUnionLiteralType(asUnionLiteral);
 	case ClassLiteral:
 		auto asClassLiteral = cast(ir.ClassLiteral) exp;
 		assert(asClassLiteral !is null);
@@ -185,9 +188,17 @@ ir.Type getStructLiteralType(ir.StructLiteral slit)
 	return slit.type;
 }
 
-ir.Type getClassLiteralType(ir.ClassLiteral clit)
+ir.Type getUnionLiteralType(ir.UnionLiteral ulit)
 {
-	return clit.type;
+	if (ulit.type is null) {
+		throw panic(/*#ref*/ulit.loc, "null union literal");
+	}
+	return ulit.type;
+}
+
+ir.Type getClassLiteralType(ir.ClassLiteral classlit)
+{
+	return classlit.type;
 }
 
 ir.Type getExpReferenceType(ir.ExpReference expref)