private AstUsingStmt AnalyseUseStatement(AstUsingStmt use)
{
use.Value.SetFlag(ExprFlags.ValueRequired, true);
use.Value.AttachTo(use);
use.Value = InferType(use.Value, null);
if (use.Value.Type.IsErrorType)
{
return(use);
}
switch (use.Value.Type)
{
case CheezTypeType type:
HandleUseType(use);
break;
case StructType str:
{
var tempVar = use.Value;
//if (!tempVar.GetFlag(ExprFlags.IsLValue))
{
tempVar = new AstTempVarExpr(use.Value, use.Value.GetFlag(ExprFlags.IsLValue));
tempVar.Replace(use.Value);
tempVar.SetFlag(ExprFlags.IsLValue, true);
tempVar = InferType(tempVar, use.Value.Type);
use.Value = tempVar;
}
ComputeStructMembers(str.Declaration);
foreach (var mem in str.Declaration.Members)
{
AstExpression expr = new AstDotExpr(tempVar, new AstIdExpr(mem.Name, false, use.Location), use.Location);
//expr = InferType(expr, null);
use.Scope.DefineUse(mem.Name, expr, true, out var u);
}
}
break;
default:
ReportError(use, $"Can't use value of type '{use.Value.Type}'");
break;
}
return(use);
}
public virtual ReturnType VisitTempVarExpr(AstTempVarExpr expr, DataType data = default) => default;
private AstExpression MatchPatternWithExpression(AstAssignment ass, AstExpression pattern, AstExpression value)
{
// check for operator set[]
if (ass.Pattern is AstArrayAccessExpr arr)
{
// before we search for operators, make sure that all impls for both arguments have been matched
GetImplsForType(arr.SubExpression.Type);
GetImplsForType(arr.Arguments[0].Type);
GetImplsForType(value.Type);
var ops = ass.Scope.GetNaryOperators("set[]", arr.SubExpression.Type, arr.Arguments[0].Type, value.Type);
if (ops.Count == 0)
{
var type = arr.SubExpression.Type;
if (type is ReferenceType r)
{
type = r.TargetType;
}
else
{
type = ReferenceType.GetRefType(type, true);
}
ops = ass.Scope.GetNaryOperators("set[]", type, arr.Arguments[0].Type, value.Type);
}
if (ops.Count == 0)
{
if (!pattern.TypeInferred)
{
pattern.SetFlag(ExprFlags.AssignmentTarget, false);
ass.Pattern = pattern = InferType(pattern, null);
}
}
else if (ops.Count == 1)
{
arr.SubExpression = HandleReference(arr.SubExpression, ops[0].ArgTypes[0], null);
var args = new List <AstExpression>
{
arr.SubExpression,
arr.Arguments[0],
value
};
var opCall = new AstNaryOpExpr("set[]", args, value.Location);
opCall.ActualOperator = ops[0];
opCall.Replace(value);
ass.OnlyGenerateValue = true;
return(InferType(opCall, null));
}
else
{
ReportError(ass, $"Multiple operators 'set[]' match the types ({arr.SubExpression.Type}, {arr.Arguments[0].Type}, {value.Type})");
}
}
if (ass.Operator != null)
{
var assOp = ass.Operator + "=";
var valType = LiteralTypeToDefaultType(value.Type);
// before we search for operators, make sure that all impls for both arguments have been matched
GetImplsForType(pattern.Type);
GetImplsForType(valType);
var ops = ass.Scope.GetBinaryOperators(assOp, pattern.Type, valType);
if (ops.Count == 0)
{
var type = pattern.Type;
if (type is ReferenceType r)
{
type = r.TargetType;
}
else
{
type = ReferenceType.GetRefType(type, true);
}
ops = ass.Scope.GetBinaryOperators(assOp, type, valType);
}
if (ops.Count == 1)
{
ass.OnlyGenerateValue = true;
pattern = HandleReference(pattern, ops[0].LhsType, null);
var opCall = new AstBinaryExpr(assOp, pattern, value, value.Location);
opCall.Replace(value);
return(InferType(opCall, null));
}
else if (ops.Count > 1)
{
ReportError(ass, $"Multiple operators '{assOp}' match the types {PointerType.GetPointerType(pattern.Type, true)} and {value.Type}");
}
}
switch (pattern)
{
case AstIdExpr id:
{
if (!id.GetFlag(ExprFlags.IsLValue))
{
ReportError(pattern, $"Can't assign to '{id}' because it is not an lvalue");
}
if (ass.Operator != null)
{
AstExpression newVal = new AstBinaryExpr(ass.Operator, pattern, value, value.Location);
newVal.Replace(value);
newVal = InferType(newVal, pattern.Type);
return(newVal);
}
ConvertLiteralTypeToDefaultType(ass.Value, pattern.Type);
return(CheckType(ass.Value, ass.Pattern.Type, $"Can't assign a value of type {ass.Value.Type} to a pattern of type {ass.Pattern.Type}"));
}
case AstTupleExpr t:
{
if (value is AstTupleExpr v)
{
if (t.Values.Count != v.Values.Count)
{
ReportError(ass, $"Can't assign the tuple '{v}' to the pattern '{t}' because the amount of values does not match");
return(value);
}
// create new assignments for all sub values
for (int i = 0; i < t.Values.Count; i++)
{
var subPat = t.Values[i];
var subVal = v.Values[i];
var subAss = new AstAssignment(subPat, subVal, ass.Operator, ass.Location);
subAss.Scope = ass.Scope;
subAss.Value = MatchPatternWithExpression(subAss, subPat, subVal);
ass.AddSubAssignment(subAss);
}
}
else
{
var tmp = new AstTempVarExpr(value);
tmp.SetFlag(ExprFlags.IsLValue, true);
// create new assignments for all sub values
for (int i = 0; i < t.Values.Count; i++)
{
AstExpression subVal = new AstArrayAccessExpr(tmp, new AstNumberExpr(i));
subVal.Scope = ass.Scope;
subVal = InferType(subVal, t.Values[i].Type);
var subAss = new AstAssignment(t.Values[i], subVal, ass.Operator, ass.Location);
subAss.Scope = ass.Scope;
subAss.Value = MatchPatternWithExpression(subAss, t.Values[i], subVal);
ass.AddSubAssignment(subAss);
}
}
break;
}
case AstDereferenceExpr de:
{
if (!pattern.GetFlag(ExprFlags.IsLValue))
{
ReportError(pattern, $"Can't assign to '{pattern}' because it is not an lvalue");
}
if (ass.Operator != null)
{
if (!de.SubExpression.GetFlag(ExprFlags.IsLValue))
{
AstExpression tmp = new AstTempVarExpr(de.SubExpression);
tmp.SetFlag(ExprFlags.IsLValue, true);
tmp = InferType(tmp, de.SubExpression.Type);
de.SubExpression = tmp;
}
AstExpression newVal = new AstBinaryExpr(ass.Operator, pattern, value, value.Location);
newVal.Replace(value);
newVal = InferType(newVal, pattern.Type);
return(newVal);
}
ConvertLiteralTypeToDefaultType(ass.Value, pattern.Type);
return(CheckType(ass.Value, ass.Pattern.Type, $"Can't assign a value of type {value.Type} to a pattern of type {pattern.Type}"));
}
case AstDotExpr dot:
{
if (!pattern.GetFlag(ExprFlags.IsLValue))
{
ReportError(pattern, $"Can't assign to '{pattern}' because it is not an lvalue");
}
if (ass.Operator != null)
{
AstExpression tmp = new AstTempVarExpr(dot.Left, true);
tmp.SetFlag(ExprFlags.IsLValue, true);
//tmp = new AstDereferenceExpr(tmp, tmp.Location);
tmp = InferType(tmp, dot.Left.Type);
dot.Left = tmp;
AstExpression newVal = new AstBinaryExpr(ass.Operator, pattern, value, value.Location);
newVal.Replace(value);
newVal = InferType(newVal, pattern.Type);
return(newVal);
}
ConvertLiteralTypeToDefaultType(ass.Value, pattern.Type);
return(CheckType(ass.Value, ass.Pattern.Type, $"Can't assign a value of type {value.Type} to a pattern of type {pattern.Type}"));
}
case AstArrayAccessExpr index:
{
if (!pattern.GetFlag(ExprFlags.IsLValue))
{
ReportError(pattern, $"Can't assign to '{pattern}' because it is not an lvalue");
}
if (ass.Operator != null)
{
AstExpression tmp = new AstTempVarExpr(index.SubExpression, true);
tmp.SetFlag(ExprFlags.IsLValue, true);
tmp = InferType(tmp, index.SubExpression.Type);
index.SubExpression = tmp;
AstExpression newVal = new AstBinaryExpr(ass.Operator, pattern, value, value.Location);
newVal.Replace(value);
newVal = InferType(newVal, pattern.Type);
return(newVal);
}
ConvertLiteralTypeToDefaultType(ass.Value, pattern.Type);
return(CheckType(ass.Value, ass.Pattern.Type, $"Can't assign a value of type {value.Type} to a pattern of type {pattern.Type}"));
}
case AstExpression e when e.Type is ReferenceType r:
{
if (!pattern.GetFlag(ExprFlags.IsLValue))
{
ReportError(pattern, $"Can't assign to '{pattern}' because it is not an lvalue");
}
// TODO: check if can be assigned to id (e.g. not const)
if (ass.Operator != null)
{
AstExpression newVal = new AstBinaryExpr(ass.Operator, pattern, value, value.Location);
newVal.Replace(value);
newVal = InferType(newVal, pattern.Type);
return(newVal);
}
ConvertLiteralTypeToDefaultType(ass.Value, pattern.Type);
return(CheckType(ass.Value, r.TargetType, $"Can't assign a value of type {value.Type} to a pattern of type {pattern.Type}"));
}
default: ReportError(pattern, $"Can't assign to '{pattern.Type}', not an lvalue"); break;
}
return(value);
}
public override string VisitTempVarExpr(AstTempVarExpr te, int data = 0)
{
return($"@tempvar({te.Id})");
}
