public void HasUniqueTypeVariableAsItsType()
{
using (TypeVariable.TestFactory())
{
Type("null").ShouldEqual(NamedType.Nullable(new TypeVariable(6)));
}
}
public void CanCreateFullyTypedInstance()
{
using (TypeVariable.TestFactory())
{
var @null = (Null)Parse("null");
@null.Type.ShouldEqual(Unknown);
var typedNull = WithTypes(@null);
typedNull.Type.ShouldEqual(NamedType.Nullable(new TypeVariable(6)));
}
}
public void ShouldGetNestedClosedTypesForWellKnownGenericTypes()
{
var nestedTypeName =
TypeName.Vector(
TypeName.Enumerable(
TypeName.Nullable(TypeName.Integer)));
var nestedType = typeRegistry.TypeOf(nestedTypeName);
nestedType.ShouldEqual("Rook.Core.Collections.Vector",
"Rook.Core.Collections.Vector<System.Collections.Generic.IEnumerable<Rook.Core.Nullable<int>>>",
NamedType.Enumerable(NamedType.Nullable(NamedType.Integer)));
}
public GlobalScope()
{
globals = new BindingDictionary();
DataType @int = NamedType.Integer;
DataType @bool = NamedType.Boolean;
DataType integerOperation = NamedType.Function(new[] { @int, @int }, @int);
DataType integerComparison = NamedType.Function(new[] { @int, @int }, @bool);
DataType booleanOperation = NamedType.Function(new[] { @bool, @bool }, @bool);
globals["<"] = integerComparison;
globals["<="] = integerComparison;
globals[">"] = integerComparison;
globals[">="] = integerComparison;
globals["=="] = integerComparison;
globals["!="] = integerComparison;
globals["+"] = integerOperation;
globals["*"] = integerOperation;
globals["/"] = integerOperation;
globals["-"] = integerOperation;
globals["&&"] = booleanOperation;
globals["||"] = booleanOperation;
globals["!"] = NamedType.Function(new[] { @bool }, @bool);
var T = TypeVariable.CreateGeneric(); //TypeVariable 0
var S = TypeVariable.CreateGeneric(); //TypeVariable 1
var enumerableT = NamedType.Enumerable(T);
var nullableT = NamedType.Nullable(T);
var vectorT = NamedType.Vector(T);
var enumerableS = NamedType.Enumerable(S);
globals["??"] = NamedType.Function(new DataType[] { nullableT, T }, T);
globals["Print"] = NamedType.Function(new[] { T }, NamedType.Void);
globals["Nullable"] = NamedType.Function(new[] { T }, nullableT);
globals["First"] = NamedType.Function(new[] { enumerableT }, T);
globals["Take"] = NamedType.Function(new[] { enumerableT, @int }, enumerableT);
globals["Skip"] = NamedType.Function(new[] { enumerableT, @int }, enumerableT);
globals["Any"] = NamedType.Function(new[] { enumerableT }, @bool);
globals["Count"] = NamedType.Function(new[] { enumerableT }, @int);
globals["Select"] = NamedType.Function(new[] { enumerableT, NamedType.Function(new[] { T }, S) }, enumerableS);
globals["Where"] = NamedType.Function(new[] { enumerableT, NamedType.Function(new[] { T }, @bool) }, enumerableT);
globals["Each"] = NamedType.Function(new[] { vectorT }, enumerableT);
globals[ReservedName.__index__] = NamedType.Function(new[] { vectorT, @int }, T);
globals[ReservedName.__slice__] = NamedType.Function(new[] { vectorT, @int, @int }, vectorT);
globals["Append"] = NamedType.Function(new DataType[] { vectorT, T }, vectorT);
globals["With"] = NamedType.Function(new[] { vectorT, @int, T }, vectorT);
}
public NamedType TypeOf(TypeName name)
{
if (!types.ContainsKey(name))
{
if (name.Name == typeof(IEnumerable <>).QualifiedName())
{
var itemType = TypeOf(name.GenericArguments.Single());
if (itemType == null)
{
return(null);
}
types.Add(name, NamedType.Enumerable(itemType));
}
else if (name.Name == typeof(Vector <>).QualifiedName())
{
var itemType = TypeOf(name.GenericArguments.Single());
if (itemType == null)
{
return(null);
}
types.Add(name, NamedType.Vector(itemType));
}
else if (name.Name == typeof(Nullable <>).QualifiedName())
{
var itemType = TypeOf(name.GenericArguments.Single());
if (itemType == null)
{
return(null);
}
types.Add(name, NamedType.Nullable(itemType));
}
else
{
return(null);
}
}
return(types[name]);
}
public Expression TypeCheck(Null nullLiteral, Scope scope)
{
var Position = nullLiteral.Position;
return(new Null(Position, NamedType.Nullable(TypeVariable.CreateGeneric())));
}
