/// <summary>
/// Parses a type reference.
/// <see cref="ITypeNode" />:
/// - NamedType
/// - ListType
/// - NonNullType
/// </summary>
/// <param name="context">The parser context.</param>
private ITypeNode ParseTypeReference(ParserContext context)
{
SyntaxToken start = context.Current;
ITypeNode type;
Location location;
if (context.Skip(TokenKind.LeftBracket))
{
type = ParseTypeReference(context);
context.ExpectRightBracket();
location = context.CreateLocation(start);
type = new ListTypeNode(location, type);
}
else
{
type = ParseNamedType(context);
}
if (context.Skip(TokenKind.Bang))
{
if (type is INullableType nt)
{
return(new NonNullTypeNode
(
context.CreateLocation(start),
nt
));
}
context.Unexpected(context.Current.Previous);
}
return(type);
}
public static void WriteListType(
this DocumentWriter writer,
ListTypeNode node)
{
writer.Write('[');
writer.WriteType(node.Type);
writer.Write(']');
}
public virtual VisitorAction Leave(
ListTypeNode node,
ISyntaxNode parent,
IReadOnlyList <object> path,
IReadOnlyList <ISyntaxNode> ancestors)
{
return(GetDefaultAction(node.Kind));
}
protected virtual void ResolveChildren(
ListTypeNode node,
IList <SyntaxNodeInfo> children)
{
ResolveChildren(
nameof(node.Type),
node.Type,
children);
}
public void Create_With_Type()
{
// arrange
var namedType = new NamedTypeNode("abc");
// act
var type = new ListTypeNode(namedType);
// assert
Assert.Equal(namedType, type.Type);
}
protected virtual ListTypeNode RewriteListType(
ListTypeNode node,
TContext context)
{
ListTypeNode current = node;
current = Rewrite(current, current.Type, context,
RewriteType, current.WithType);
return(current);
}
public void Create_With_Location_And_Type_Where_Location_Is_Null()
{
// arrange
var namedType = new NamedTypeNode("abc");
// act
var type = new ListTypeNode(null, namedType);
// assert
Assert.Null(type.Location);
Assert.Equal(namedType, type.Type);
}
public void InnerTypeFromListType()
{
// arrange
var namedType = new NamedTypeNode(null, new NameNode("Foo"));
var listType = new ListTypeNode(null, namedType);
// act
ITypeNode innerType = listType.InnerType();
// assert
Assert.Equal(namedType, innerType);
}
public void Create_With_Location_And_Type()
{
// arrange
var location = new Location(1, 1, 1, 1);
var namedType = new NamedTypeNode("abc");
// act
var type = new ListTypeNode(location, namedType);
// assert
Assert.Equal(location, type.Location);
Assert.Equal(namedType, type.Type);
}
public void WithType_Where_Type_Is_Null()
{
// arrange
var location = new Location(1, 1, 1, 1);
var initialType = new NamedTypeNode("abc");
var type = new ListTypeNode(location, initialType);
// act
Action action = () => type.WithType(null);
// assert
Assert.Throws <ArgumentNullException>(action);
}
public void WithLocation_Where_Location_Is_Null()
{
// arrange
var initialLocation = new Location(1, 1, 1, 1);
var namedType = new NamedTypeNode("abc");
var type = new ListTypeNode(initialLocation, namedType);
// act
type = type.WithLocation(null);
// assert
Assert.Null(type.Location);
Assert.Equal(namedType, type.Type);
}
public void NamedTypeFromNonNullList()
{
// arrange
var namedType = new NamedTypeNode(null, new NameNode("Foo"));
var listType = new ListTypeNode(null,
new NonNullTypeNode(null, namedType));
var nonNullType = new NonNullTypeNode(null, listType);
// act
NamedTypeNode retrievedNamedType = nonNullType.NamedType();
// assert
Assert.Equal(namedType, retrievedNamedType);
}
public void IsListType()
{
// arrange
var namedType = new NamedTypeNode(null, new NameNode("Foo"));
var listType = new ListTypeNode(null, namedType);
// act
bool shouldBeFalse = namedType.IsListType();
bool shouldBeTrue = listType.IsListType();
// assert
Assert.False(shouldBeFalse);
Assert.True(shouldBeTrue);
}
public void InvalidTypeStructure()
{
// arrange
var namedType = new NamedTypeNode(null, new NameNode("Foo"));
var listType = new ListTypeNode(null, new ListTypeNode(null,
new NonNullTypeNode(null, namedType)));
var nonNullType = new NonNullTypeNode(null, listType);
// act
Action a = () => nonNullType.NamedType();
// assert
Assert.Throws <NotSupportedException>(a);
}
public void WithType()
{
// arrange
var location = new Location(1, 1, 1, 1);
var initialType = new NamedTypeNode("abc");
var type = new ListTypeNode(location, initialType);
// act
var newType = new NamedTypeNode("def");
type = type.WithType(newType);
// assert
Assert.Equal(location, type.Location);
Assert.Equal(newType, type.Type);
}
public void WithLocation()
{
// arrange
var initialLocation = new Location(1, 1, 1, 1);
var namedType = new NamedTypeNode("abc");
var type = new ListTypeNode(initialLocation, namedType);
// act
var newLocation = new Location(2, 2, 2, 2);
type = type.WithLocation(newLocation);
// assert
Assert.Equal(newLocation, type.Location);
Assert.Equal(namedType, type.Type);
}
protected virtual void VisitListType(
ListTypeNode node,
TContext context)
{
}
protected virtual ListTypeNode RewriteListType(
ListTypeNode node,
TContext context)
{
return(node);
}
protected override void VisitListType(ListTypeNode node)
{
_writer.Write('[');
VisitType(node.Type);
_writer.Write(']');
}
protected virtual void VisitListType(ListTypeNode node)
{
}
