void ResultIsBoolAndBothOperandsMustBeBool(BinaryOp binaryOp)
{
binaryOp.Left.Accept(this);
MustBeBool("The type of the left operand of " + binaryOp + " must be bool");
binaryOp.Right.Accept(this);
MustBeBool("The type of the right operand of " + binaryOp + " must be bool");
binaryOp.Type = _result = _boolType;
}
void ResultIsIntAndBothOperandsMustBeInt(BinaryOp binaryOp)
{
binaryOp.Left.Accept(this);
MustBeInt("The type of the left operand of " + binaryOp + " must be integer");
binaryOp.Right.Accept(this);
MustBeInt("The type of the right operand of " + binaryOp + " must be integer");
binaryOp.Type = _result = _intType;
}
Type AddType(string name, TypeReference reference)
{
name = name.ToLower();
Raise<TypeCheckException>.If(_types.ContainsKey(name), "Type already existing.");
var type = new Type(name, reference);
_types.Add(name, type);
return type;
}
Type MustBe(Type t, string msg)
{
Raise<TypeCheckException>.IfAreNotSame(_result, t, msg);
return t;
}
public void Visit(FunctionCall fc)
{
Raise<TypeCheckException>.If(!_funcDecls.ContainsKey(fc.FunctionName), "Function not existing");
var fd = _funcDecls[fc.FunctionName];
Raise<TypeCheckException>.IfAreNotEqual(fc.Arguments.Count, fd.Params.Count, "Wrong argument count!");
for (var i = 0; i < fd.Params.Count; ++i) {
fc.Arguments[i].Accept(this);
Raise<TypeCheckException>.IfAreNotSame(fc.Arguments[i].Type, fd.Params[i].Type, "Wrong parameter type");
}
fc.Function = fd;
fc.Type = _result = fd.ReturnType;
}
public void Visit(Id id)
{
var v = _staticEnv.GetVariable(id.Name);
id.Var = v;
id.Type = _result = v.Type;
}
public void Visit(IntLiteral il)
{
_result = il.Type = _intType;
}
public void Visit(StructValue sv)
{
var st = GetStructType(sv.Name);
Raise<TypeCheckException>.IfAreNotEqual(st.Fields.Count, sv.Values.Count, "Wrong field count");
for (var i = 0; i < st.Fields.Count; ++i) {
sv.Values[i].Accept(this);
Raise<TypeCheckException>.IfAreNotSame(st.Fields[i].Type, sv.Values[i].Type, "Wrong field type");
}
sv.Type = _result = st;
sv.Temp = _currFunc.AddVariable("$" + _tempCounter++, st);
}
public void Visit(Dot dot)
{
dot.Left.Accept(this);
var st = dot.Left.Type as StructType;
Raise<TypeCheckException>.IfIsNull(st, "Cannot call dot on struct types!");
Debug.Assert(st != null); // To keep ReSharper quiet :)
dot.Type = _result = st.GetField(dot.Right).Type;
}
public void Visit(BoolLiteral bl)
{
_result = bl.Type = _boolType;
}
public void Visit(Equal eq)
{
eq.Left.Accept(this);
eq.Right.Accept(this);
if (!eq.Left.Type.Equals(eq.Right.Type)) {
throw new TypeCheckException("Both operands of == must have the same type");
}
eq.Type = _result = _boolType;
}
public TypecheckVisitor()
{
Assembly = AssemblyDefinition.ReadAssembly("DanglingLang.Runner.exe");
Module = Assembly.MainModule;
_boolType = AddType("bool", Module.TypeSystem.Boolean);
_intType = AddType("int", Module.TypeSystem.Int32);
_voidType = AddType("void", Module.TypeSystem.Void);
// To allow "load" functionality...
_types.Add("boolean", _boolType);
_types.Add("int32", _intType);
}
public FieldInfo(string name, Type type)
{
Name = name;
Type = type;
}
public FieldInfo AddField(string name, Type type)
{
Raise<TypeCheckException>.If(_fields.Any(f => f.Name == name), "Field with existing name");
var fieldInfo = new FieldInfo(name, type);
_fields.Add(fieldInfo);
return fieldInfo;
}
public VarInfo(string name, Type type, Kind kind, object info)
{
Name = name;
Type = type;
Kind = kind;
Debug.Assert(info is FunctionDecl.ParamInfo || info is FunctionDecl.VarInfo || info is StructType.FieldInfo);
Info = info;
}