//check condtion type and set returned type as in if
public override void Visit(WhileNode node)
{
_stack_of_while_node.Add(node);
base.Visit(node);
_stack_of_while_node.Remove(node);
TypeNode _type_to_set;
if (!NamedTypeNode.BoolType().Equals(node.Condition.ExpressionType, false))
{
throw new Exception("Inpropper type in if condition");
}
if (!node.HasElse || !node.Body.ExpressionType.Equals(node.Else.ExpressionType))
{
_type_to_set = NamedTypeNode.VoidType();
}
else
{
_type_to_set = node.Body.ExpressionType;
}
if (node.ExpressionType == null)
{
node.ExpressionType = _type_to_set;
}
else
if (!node.ExpressionType.Equals(_type_to_set))
{
throw new Exception("Type of Body and Else is not correct with set type.");
}
else
{
node.ExpressionType = _type_to_set;
}
}
public void ProgramWithAdditionAndMultiplication()
{
var tree = ExpressionProgram(AddMulExpression());
var expected = new ProgramNode(new LinkedList <FunctionDefinitionNode>(new FunctionDefinitionNode[] {
new FunctionDefinitionNode(
"MyFunc",
new LinkedList <VariableDeclNode>(),
NamedTypeNode.IntType(true),
new OperatorNode(
OperatorType.PLUS,
new ExpressionNode[] {
new AtomNode(NamedTypeNode.IntType(true), "1"),
new OperatorNode(
OperatorType.MUL,
new ExpressionNode[] {
new AtomNode(NamedTypeNode.IntType(true), "2"),
new AtomNode(NamedTypeNode.IntType(true), "3"),
}
)
}
)
)
}), new LinkedList <RecordTypeDeclarationNode>());
ConductTest(tree, expected);
}
private HashSet <TypeNode> deduceType(string value)
{
HashSet <TypeNode> _set_of_types = new HashSet <TypeNode>();
bool out_bool;
if (Boolean.TryParse(value, out out_bool))
{
_set_of_types.Add(NamedTypeNode.BoolType(true));
}
byte out_byte;
if (Byte.TryParse(value, out out_byte))
{
_set_of_types.Add(NamedTypeNode.ByteType(true));
}
int out_int;
if (Int32.TryParse(value, out out_int))
{
_set_of_types.Add(NamedTypeNode.IntType(true));
}
char out_char;
if (value.Length == 3 && Char.TryParse(value.Trim(new char[] { '\'' }), out out_char))
{
_set_of_types.Add(NamedTypeNode.CharType(true));
}
return(_set_of_types);
}
internal static NamedTypeNode MakePrimitiveType(PrimitiveType type, Mutablitity isConstant)
{
NamedTypeNode result = null;
switch (type)
{
case PrimitiveType.Int:
result = NamedTypeNode.IntType();
break;
case PrimitiveType.Byte:
result = NamedTypeNode.ByteType();
break;
case PrimitiveType.Char:
result = NamedTypeNode.CharType();
break;
case PrimitiveType.Bool:
result = NamedTypeNode.BoolType();
break;
case PrimitiveType.Void:
result = NamedTypeNode.VoidType();
break;
default:
throw new Exception("Wrong primitive type");
}
result.IsConstant = isConstant == Mutablitity.Constant;
return(result);
}
private static void ResolveOperations(
SchemaTypesDefinition schemaDef,
Dictionary <OperationType, ITypeReference> operations,
TypeRegistry typeRegistry)
{
if (operations.Count == 0)
{
schemaDef.QueryType = GetObjectType(OperationTypeNames.Query);
schemaDef.MutationType = GetObjectType(OperationTypeNames.Mutation);
schemaDef.SubscriptionType = GetObjectType(OperationTypeNames.Subscription);
}
else
{
schemaDef.QueryType = GetOperationType(OperationType.Query);
schemaDef.MutationType = GetOperationType(OperationType.Mutation);
schemaDef.SubscriptionType = GetOperationType(OperationType.Subscription);
}
ObjectType?GetObjectType(NameString typeName)
{
foreach (RegisteredType registeredType in typeRegistry.Types)
{
if (registeredType.Type is ObjectType objectType &&
objectType.Name.Equals(typeName))
{
return(objectType);
}
}
return(null);
}
ObjectType?GetOperationType(OperationType operation)
{
if (operations.TryGetValue(operation, out ITypeReference? reference))
{
if (reference is SchemaTypeReference sr)
{
return((ObjectType)sr.Type);
}
if (reference is ExtendedTypeReference cr &&
typeRegistry.TryGetType(cr, out RegisteredType? registeredType))
{
return((ObjectType)registeredType.Type);
}
if (reference is SyntaxTypeReference str)
{
NamedTypeNode namedType = str.Type.NamedType();
return(typeRegistry.Types
.Select(t => t.Type)
.OfType <ObjectType>()
.FirstOrDefault(t => t.Name.Equals(namedType.Name.Value)));
}
}
return(null);
}
}
internal static VariableDeclNode Declaration(string name, NamedTypeNode type)
{
return(new VariableDeclNode {
Name = name,
Type = type,
ExpressionType = type
});
}
//check if body returns the same as set type
public override void Visit(FunctionDefinitionNode node)
{
base.Visit(node);
if (!node.ResultType.Equals(node.Body.ExpressionType, false))
{
throw new TypeCheckException("Body doesn't return the same type as set type.");
}
node.ExpressionType = NamedTypeNode.VoidType();
}
//check if number is int and rewrite ExpressionType to Array type
public override void Visit(ElementNode node)
{
base.Visit(node);
if (!NamedTypeNode.IntType().Equals(node.Index.ExpressionType, false))
{
throw new TypeCheckException("Index is not integer type.");
}
node.ExpressionType = node.Array.ExpressionType;
}
protected void Interface(NamedTypeNode type)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
ObjectDescription.Interfaces.Add(new TypeReference(type));
}
public IUnionTypeDescriptor Type(NamedTypeNode objectType)
{
if (objectType is null)
{
throw new ArgumentNullException(nameof(objectType));
}
Definition.Types.Add(TypeReference.Create(objectType, TypeContext.Output));
return(this);
}
public IInterfaceTypeDescriptor Implements(NamedTypeNode type)
{
if (type is null)
{
throw new ArgumentNullException(nameof(type));
}
Definition.Interfaces.Add(TypeReference.Create(type, TypeContext.Output));
return(this);
}
IObjectTypeDescriptor IObjectTypeDescriptor.Interface(NamedTypeNode type)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
Interfaces = Interfaces.Add(new TypeReference(type));
return(this);
}
public void TypeNode_NamedTypeNodeHash_Test()
{
var hashSet = new HashSet <TypeNode>();
hashSet.Add(NamedTypeNode.BoolType());
Assert.AreEqual(1, hashSet.Count);
Assert.IsTrue(hashSet.Contains(NamedTypeNode.BoolType()));
Assert.IsFalse(hashSet.Contains(NamedTypeNode.ByteType()));
Assert.IsFalse(hashSet.Contains(NamedTypeNode.CharType()));
Assert.IsFalse(hashSet.Contains(NamedTypeNode.IntType()));
Assert.IsFalse(hashSet.Contains(NamedTypeNode.VoidType()));
hashSet.Add(NamedTypeNode.BoolType());
Assert.AreEqual(1, hashSet.Count);
hashSet.Add(NamedTypeNode.ByteType());
Assert.AreEqual(2, hashSet.Count);
Assert.IsTrue(hashSet.Contains(NamedTypeNode.BoolType()));
Assert.IsTrue(hashSet.Contains(NamedTypeNode.ByteType()));
Assert.IsFalse(hashSet.Contains(NamedTypeNode.CharType()));
Assert.IsFalse(hashSet.Contains(NamedTypeNode.IntType()));
Assert.IsFalse(hashSet.Contains(NamedTypeNode.VoidType()));
hashSet.Add(NamedTypeNode.ByteType());
Assert.AreEqual(2, hashSet.Count);
hashSet.Add(NamedTypeNode.CharType());
Assert.AreEqual(3, hashSet.Count);
Assert.IsTrue(hashSet.Contains(NamedTypeNode.BoolType()));
Assert.IsTrue(hashSet.Contains(NamedTypeNode.ByteType()));
Assert.IsTrue(hashSet.Contains(NamedTypeNode.CharType()));
Assert.IsFalse(hashSet.Contains(NamedTypeNode.IntType()));
Assert.IsFalse(hashSet.Contains(NamedTypeNode.VoidType()));
hashSet.Add(NamedTypeNode.CharType());
Assert.AreEqual(3, hashSet.Count);
hashSet.Add(NamedTypeNode.IntType());
Assert.AreEqual(4, hashSet.Count);
Assert.IsTrue(hashSet.Contains(NamedTypeNode.BoolType()));
Assert.IsTrue(hashSet.Contains(NamedTypeNode.ByteType()));
Assert.IsTrue(hashSet.Contains(NamedTypeNode.CharType()));
Assert.IsTrue(hashSet.Contains(NamedTypeNode.IntType()));
Assert.IsFalse(hashSet.Contains(NamedTypeNode.VoidType()));
hashSet.Add(NamedTypeNode.IntType());
Assert.AreEqual(4, hashSet.Count);
hashSet.Add(NamedTypeNode.VoidType());
Assert.AreEqual(5, hashSet.Count);
Assert.IsTrue(hashSet.Contains(NamedTypeNode.BoolType()));
Assert.IsTrue(hashSet.Contains(NamedTypeNode.ByteType()));
Assert.IsTrue(hashSet.Contains(NamedTypeNode.CharType()));
Assert.IsTrue(hashSet.Contains(NamedTypeNode.IntType()));
Assert.IsTrue(hashSet.Contains(NamedTypeNode.VoidType()));
hashSet.Add(NamedTypeNode.VoidType());
Assert.AreEqual(5, hashSet.Count);
}
protected override NamedTypeNode RewriteNamedType(
NamedTypeNode node,
Context context)
{
if (context.Names.TryGetValue(node.Name.Value,
out NameString newName))
{
return(node.WithName(node.Name.WithValue(newName)));
}
return(node);
}
//type is the last one element, if don't have set void
public override void Visit(BlockExpressionNode node)
{
base.Visit(node);
TypeNode last_element_type = NamedTypeNode.VoidType();
foreach (var element in node.Elements)
{
last_element_type = element.ExpressionType;
}
node.ExpressionType = last_element_type;
}
public IObjectTypeDescriptor Interface(
NamedTypeNode namedTypeNode)
{
if (namedTypeNode == null)
{
throw new ArgumentNullException(nameof(namedTypeNode));
}
Definition.Interfaces.Add(new SyntaxTypeReference(
namedTypeNode, TypeContext.Output));
return(this);
}
public void TypeCheck_AssignIf_Test()
{
var _2_sub_3 = Utils.Sub(Utils.IntLiteral(2), Utils.IntLiteral(3));
var _if = Utils.IfElse(Utils.BoolLiteral(true), Utils.IntLiteral(5), _2_sub_3);
var _decl = Utils.Declaration("x", NamedTypeNode.IntType());
var _def = Utils.Definition(_decl, _if);
_def.Accept(new TypeCheckVisitor());
Assert.IsTrue(NamedTypeNode.IntType().Equals(_def.ExpressionType));
}
//write type the same as in array node and check if Left and Right have int type
public override void Visit(SliceNode node)
{
base.Visit(node);
if (!NamedTypeNode.IntType().Equals(node.Left.ExpressionType, false))
{
throw new TypeCheckException("Left is not int value.");
}
if (!NamedTypeNode.IntType().Equals(node.Right.ExpressionType, false))
{
throw new TypeCheckException("Right is not int value.");
}
node.ExpressionType = node.Array.ExpressionType;
((ArrayTypeNode)node.ExpressionType).IsFixedSize = false;
}
public void ProgramWithTheSimplestFunction()
{
var tree = ExpressionProgram(NumberExpression());
var expected = new ProgramNode(new LinkedList <FunctionDefinitionNode>(new FunctionDefinitionNode[] {
new FunctionDefinitionNode(
"MyFunc",
new LinkedList <VariableDeclNode>(),
NamedTypeNode.IntType(true),
new AtomNode(NamedTypeNode.IntType(true), "42")
)
}), new LinkedList <RecordTypeDeclarationNode>());
ConductTest(tree, expected);
}
//check if condition is bool and set common return type of Then and Else
public override void Visit(IfNode node)
{
base.Visit(node);
if (!NamedTypeNode.BoolType().Equals(node.Condition.ExpressionType, false))
{
throw new Exception("Improper type in if condition");
}
if (!node.HasElse || !node.Then.ExpressionType.Equals(node.Else.ExpressionType, false))
{
node.ExpressionType = NamedTypeNode.VoidType();
}
else
{
node.ExpressionType = node.Then.ExpressionType;
}
}
public static IError FragmentTypeConditionUnknown(
this IDocumentValidatorContext context,
ISyntaxNode node,
NamedTypeNode typeCondition)
{
return(ErrorBuilder.New()
.SetMessage(
Resources.ErrorHelper_FragmentTypeConditionUnknown,
typeCondition.Name.Value)
.AddLocation(node)
.SetPath(context.CreateErrorPath())
.SetExtension("typeCondition", typeCondition.Name.Value)
.SetFragmentName(node)
.SpecifiedBy("sec-Fragment-Spread-Type-Existence")
.Build());
}
public void TypeReference_Create()
{
// arrange
var namedType = new NamedTypeNode("Foo");
// act
SyntaxTypeReference typeReference = TypeReference.Create(
namedType,
TypeContext.Input,
scope: "foo");
// assert
Assert.Equal(namedType, typeReference.Type);
Assert.Equal(TypeContext.Input, typeReference.Context);
Assert.Equal("foo", typeReference.Scope);
}
private bool TryGetType <T>(
ISyntaxTypeReference reference,
out T type)
where T : IType
{
NamedTypeNode namedType = reference.Type.NamedType();
if (_typeInitializer.TryGetType(namedType.Name.Value, out IType t) &&
WrapType(t, reference.Type) is T casted)
{
type = casted;
return(true);
}
type = default;
return(false);
}
protected sealed override ISyntaxVisitorAction Enter(
ISyntaxNode node,
ISyntaxVisitorContext context)
{
return(node switch
{
DocumentNode n => Enter(n, context),
OperationDefinitionNode n => Enter(n, context),
VariableDefinitionNode n => Enter(n, context),
VariableNode n => Enter(n, context),
SelectionSetNode n => Enter(n, context),
FieldNode n => Enter(n, context),
ArgumentNode n => Enter(n, context),
FragmentSpreadNode n => Enter(n, context),
InlineFragmentNode n => Enter(n, context),
FragmentDefinitionNode n => Enter(n, context),
DirectiveNode n => Enter(n, context),
NamedTypeNode n => Enter(n, context),
ListTypeNode n => Enter(n, context),
NonNullTypeNode n => Enter(n, context),
ListValueNode n => Enter(n, context),
ObjectValueNode n => Enter(n, context),
ObjectFieldNode n => Enter(n, context),
IValueNode n => Enter(n, context),
SchemaDefinitionNode n => Enter(n, context),
OperationTypeDefinitionNode n => Enter(n, context),
ScalarTypeDefinitionNode n => Enter(n, context),
ObjectTypeDefinitionNode n => Enter(n, context),
FieldDefinitionNode n => Enter(n, context),
InputValueDefinitionNode n => Enter(n, context),
InterfaceTypeDefinitionNode n => Enter(n, context),
UnionTypeDefinitionNode n => Enter(n, context),
EnumTypeDefinitionNode n => Enter(n, context),
EnumValueDefinitionNode n => Enter(n, context),
InputObjectTypeDefinitionNode n => Enter(n, context),
DirectiveDefinitionNode n => Enter(n, context),
SchemaExtensionNode n => Enter(n, context),
ScalarTypeExtensionNode n => Enter(n, context),
ObjectTypeExtensionNode n => Enter(n, context),
InterfaceTypeExtensionNode n => Enter(n, context),
UnionTypeExtensionNode n => Enter(n, context),
EnumTypeExtensionNode n => Enter(n, context),
InputObjectTypeExtensionNode n => Enter(n, context),
_ => throw new NotSupportedException()
});
private IOutputType GetReturnType(
MatchSelectionsContext context,
FieldNode node,
IOutputType type)
{
if (GetDirective(node, "_return") is DirectiveNode directive &&
directive.Arguments.Count == 1 &&
directive.Arguments[0] is { Name: { Value : "type" } } argument&&
argument.Value is StringValueNode value)
{
ITypeNode typeSyntax = Utf8GraphQLParser.Syntax.ParseTypeReference(value.Value);
NamedTypeNode namedTypeSyntax = typeSyntax.NamedType();
var named = context.Schema.GetType <INamedOutputType>(namedTypeSyntax.Name.Value);
return((IOutputType)typeSyntax.ToType(named));
}
return(type);
}
public void TypeReference_Create()
{
// arrange
var namedType = new NamedTypeNode("Foo");
// act
SyntaxTypeReference typeReference = TypeReference.Create(
namedType,
TypeContext.Input,
scope: "foo",
nullable: new bool[] { false });
// assert
Assert.Equal(namedType, typeReference.Type);
Assert.Equal(TypeContext.Input, typeReference.Context);
Assert.Equal("foo", typeReference.Scope);
Assert.Collection(typeReference.Nullable, Assert.False);
}
public void TypeNode_NamedTypeNodeEquals_Test()
{
Assert.IsTrue(NamedTypeNode.BoolType().Equals(NamedTypeNode.BoolType()));
Assert.IsTrue(NamedTypeNode.ByteType().Equals(NamedTypeNode.ByteType()));
Assert.IsTrue(NamedTypeNode.CharType().Equals(NamedTypeNode.CharType()));
Assert.IsTrue(NamedTypeNode.IntType().Equals(NamedTypeNode.IntType()));
Assert.IsTrue(NamedTypeNode.VoidType().Equals(NamedTypeNode.VoidType()));
Assert.IsFalse(NamedTypeNode.ByteType().Equals(NamedTypeNode.VoidType()));
Assert.IsFalse(NamedTypeNode.BoolType().Equals(NamedTypeNode.VoidType()));
Assert.IsFalse(NamedTypeNode.IntType().Equals(NamedTypeNode.VoidType()));
Assert.IsFalse(NamedTypeNode.CharType().Equals(NamedTypeNode.VoidType()));
Assert.IsFalse(NamedTypeNode.BoolType().Equals(NamedTypeNode.IntType()));
Assert.IsFalse(NamedTypeNode.ByteType().Equals(NamedTypeNode.IntType()));
Assert.IsFalse(NamedTypeNode.CharType().Equals(NamedTypeNode.IntType()));
Assert.IsFalse(NamedTypeNode.BoolType().Equals(NamedTypeNode.CharType()));
Assert.IsFalse(NamedTypeNode.ByteType().Equals(NamedTypeNode.CharType()));
Assert.IsFalse(NamedTypeNode.BoolType().Equals(NamedTypeNode.ByteType()));
Assert.IsFalse(NamedTypeNode.ByteType().Equals(NamedTypeNode.BoolType()));
}
private IDictionary <string, object?> CreateTypeDto(
ITypeNode type,
IDictionary <string, TypeKind> typeKinds)
{
return(type switch
{
NonNullTypeNode nnt => new Dictionary <string, object?>
{
{ "kind", TypeKind.NonNull }, { "ofType", CreateTypeDto(nnt.Type, typeKinds) },
},
ListTypeNode lt => new Dictionary <string, object?>
{
{ "kind", TypeKind.List }, { "ofType", CreateTypeDto(lt.Type, typeKinds) },
},
NamedTypeNode nt => new Dictionary <string, object?>
{
{ "kind", typeKinds[nt.Name.Value] }, { "name", nt.Name.Value },
},
_ => throw new InvalidOperationException("Invalid Type Structure.")
});
private ObjectType ResolveOperation(
TypeInitializer initializer,
OperationType operation)
{
if (!_operations.ContainsKey(operation))
{
NameString typeName = operation.ToString();
return(initializer.Types.Values
.Select(t => t.Type)
.OfType <ObjectType>()
.FirstOrDefault(t => t.Name.Equals(typeName)));
}
else if (_operations.TryGetValue(operation,
out ITypeReference reference))
{
if (reference is ISchemaTypeReference sr)
{
return((ObjectType)sr.Type);
}
if (reference is IClrTypeReference cr &&
initializer.TryGetRegisteredType(cr,
out RegisteredType registeredType))
{
return((ObjectType)registeredType.Type);
}
if (reference is ISyntaxTypeReference str)
{
NamedTypeNode namedType = str.Type.NamedType();
return(initializer.Types.Values
.Select(t => t.Type)
.OfType <ObjectType>()
.FirstOrDefault(t => t.Name.Equals(
namedType.Name.Value)));
}
}
return(null);
}
private static ObjectType?ResolveOperation(
OperationType operation,
Dictionary <OperationType, ITypeReference> operations,
TypeRegistry typeRegistry)
{
if (!operations.ContainsKey(operation))
{
NameString typeName = operation.ToString();
return(typeRegistry.Types
.Select(t => t.Type)
.OfType <ObjectType>()
.FirstOrDefault(t => t.Name.Equals(typeName)));
}
else if (operations.TryGetValue(operation, out ITypeReference? reference))
{
if (reference is SchemaTypeReference sr)
{
return((ObjectType)sr.Type);
}
if (reference is ExtendedTypeReference cr &&
typeRegistry.TryGetType(cr, out RegisteredType? registeredType))
{
return((ObjectType)registeredType.Type);
}
if (reference is SyntaxTypeReference str)
{
NamedTypeNode namedType = str.Type.NamedType();
return(typeRegistry.Types
.Select(t => t.Type)
.OfType <ObjectType>()
.FirstOrDefault(t => t.Name.Equals(
namedType.Name.Value)));
}
}
return(null);
}
