public void Generic_strings_can_be_assigned_to_string_literals_with_loose_assignment()
{
var literalVal1 = new StringLiteralType("evie");
var literalVal2 = new StringLiteralType("casper");
var literalUnion = TypeHelper.CreateTypeUnion(literalVal1, literalVal2);
var genericString = LanguageConstants.String;
var looseString = LanguageConstants.LooseString;
// both should be treated as equivalent
TypeValidator.AreTypesAssignable(genericString, looseString).Should().BeTrue();
TypeValidator.AreTypesAssignable(looseString, genericString).Should().BeTrue();
// normal string cannot be assigned to string literal or union type of literals
TypeValidator.AreTypesAssignable(genericString, literalVal1).Should().BeFalse();
TypeValidator.AreTypesAssignable(genericString, literalUnion).Should().BeFalse();
// loose string can be assigned to string literal and a union type of literals!
TypeValidator.AreTypesAssignable(looseString, literalVal1).Should().BeTrue();
TypeValidator.AreTypesAssignable(looseString, literalUnion).Should().BeTrue();
// assignment from string literal works in both cases
TypeValidator.AreTypesAssignable(literalVal1, genericString).Should().BeTrue();
TypeValidator.AreTypesAssignable(literalVal1, looseString).Should().BeTrue();
}
public void StringLiteral_name_should_be_correctly_formatted()
{
var literal = new StringLiteralType("a'b\\c$d\re\nf\tg${h");
literal.Name.Should().StartWith("'", "literal type name should be quoted");
literal.Name.Should().EndWith("'", "literal type name should be quoted");
literal.Name.Should().Be("'a\\'b\\\\c$d\\re\\nf\\tg\\${h'", "literal type name should be escaped");
}
public override void Write(Utf8JsonWriter writer, TypeBase value, JsonSerializerOptions options)
{
writer.WriteStartObject();
var propertyEnum = value switch {
BuiltInType _ => TypeBaseKind.BuiltInType,
ObjectType _ => TypeBaseKind.ObjectType,
ArrayType _ => TypeBaseKind.ArrayType,
ResourceType _ => TypeBaseKind.ResourceType,
UnionType _ => TypeBaseKind.UnionType,
StringLiteralType _ => TypeBaseKind.StringLiteralType,
DiscriminatedObjectType _ => TypeBaseKind.DiscriminatedObjectType,
ResourceFunctionType _ => TypeBaseKind.ResourceFunctionType,
_ => throw new JsonException(),
};
writer.WritePropertyName(((int)propertyEnum).ToString());
switch (value)
{
case BuiltInType builtInType:
JsonSerializer.Serialize(writer, builtInType, serializerOptions);
break;
case ObjectType objectType:
JsonSerializer.Serialize(writer, objectType, serializerOptions);
break;
case ArrayType arrayType:
JsonSerializer.Serialize(writer, arrayType, serializerOptions);
break;
case ResourceType resourceType:
JsonSerializer.Serialize(writer, resourceType, serializerOptions);
break;
case UnionType unionType:
JsonSerializer.Serialize(writer, unionType, serializerOptions);
break;
case StringLiteralType stringLiteralType:
JsonSerializer.Serialize(writer, stringLiteralType, serializerOptions);
break;
case DiscriminatedObjectType discriminatedObjectType:
JsonSerializer.Serialize(writer, discriminatedObjectType, serializerOptions);
break;
case ResourceFunctionType resourceFunctionType:
JsonSerializer.Serialize(writer, resourceFunctionType, serializerOptions);
break;
default:
throw new JsonException();
}
writer.WriteEndObject();
}
public void StringLiteralTypesShouldBeAssignableToAndFromStrings()
{
var literalVal1 = new StringLiteralType("evie");
var literalVal2 = new StringLiteralType("casper");
// different string literals should not be assignable to each other
TypeValidator.AreTypesAssignable(literalVal1, literalVal2).Should().BeFalse();
// same-name string literals should be assignable to each other
TypeValidator.AreTypesAssignable(literalVal1, new StringLiteralType("evie")).Should().BeTrue();
// string literals should be assignable to and from regular strings
TypeValidator.AreTypesAssignable(literalVal1, LanguageConstants.String).Should().BeTrue();
TypeValidator.AreTypesAssignable(LanguageConstants.String, literalVal1).Should().BeTrue();
}
public StringLiteral(StringLiteralType type, string str)
{
Type = type;
String = str;
}
protected abstract TResult VisitString(StringLiteralType armString);
protected override DslKeywordSchema VisitString(StringLiteralType armString)
{
return(new OpenKeywordSchema(s_parameterBuilder.Visit(armString), useParametersForCompletions: true));
}
private void WriteKeywordDefinitionBody(string armKey, StringLiteralType stringLiteral, int arrayDepth)
{
WriteKeywordValueParamBlock(enumeratedValues: new string[] { stringLiteral.Value });
WritePrimitiveInvocation(armKey, KeywordArgumentKind.Value, arrayDepth);
}
protected override IReadOnlyDictionary <string, DslParameterInfo> VisitString(StringLiteralType armString)
{
return(new Dictionary <string, DslParameterInfo>(StringComparer.OrdinalIgnoreCase)
{
{ "Value", new DslParameterInfo("Value", "string", new [] { armString.Value }) },
});
}
