public LanguageExpression GetFullyQualifiedResourceName(ResourceSymbol resourceSymbol)
{
return(converter.GetFullyQualifiedResourceName(resourceSymbol));
}
public LanguageExpression GetUnqualifiedResourceId(ResourceSymbol resourceSymbol) => GenerateScopedResourceId(resourceSymbol, null);
public LanguageExpression GetLocallyScopedResourceId(ResourceSymbol resourceSymbol) => GenerateScopedResourceId(resourceSymbol, context.SemanticModel.TargetScope);
public static void RemoveReadableAtDeployTimeFlagForExistingResource(Dictionary <DeclaredSymbol, ObjectType> existingResourceBodyObjectTypeOverrides, ResourceSymbol existingResourceSymbol)
{
if (!existingResourceBodyObjectTypeOverrides.TryGetValue(existingResourceSymbol, out var value))
{
if (existingResourceSymbol.TryGetBodyObjectType() is { } objectType&& objectType.Properties.TryGetValue(AzResourceTypeProvider.ResourceNamePropertyName, out var nameProperty))
{
existingResourceBodyObjectTypeOverrides[existingResourceSymbol] = new ObjectType(
objectType.Name,
objectType.ValidationFlags,
objectType.Properties.SetItem(AzResourceTypeProvider.ResourceNamePropertyName, new TypeProperty(nameProperty.Name, LanguageConstants.String, nameProperty.Flags & ~TypePropertyFlags.ReadableAtDeployTime)).Values,
objectType.AdditionalPropertiesType,
objectType.AdditionalPropertiesFlags,
objectType.MethodResolver.CopyToObject);
}
}
}
private TypeSymbol GetResourceType(TypeManagerContext context, VariableAccessSyntax syntax, ResourceSymbol resource)
{
// resource bodies can participate in cycles
// need to explicitly force a type check on the body
if (ContainsCyclicExpressionError(this.GetTypeInfoInternal(context, resource.Body)))
{
return(new ErrorTypeSymbol(DiagnosticBuilder.ForPosition(syntax.Name.Span).CyclicExpression()));
}
return(HandleSymbolType(syntax.Name.IdentifierName, syntax.Name.Span, resource.Type));
}
public SyntaxBase?TryGetReplacementChildName(StringSyntax childName, SyntaxBase parentName, ResourceSymbol parentResourceSymbol)
{
switch (parentName)
{
case VariableAccessSyntax parentVarAccess:
{
if (childName.Expressions.FirstOrDefault() is not VariableAccessSyntax childVarAccess ||
semanticModel.GetSymbolInfo(parentVarAccess) != semanticModel.GetSymbolInfo(childVarAccess))
{
return(null);
}
if (!childName.SegmentValues[1].StartsWith("/"))
{
return(null);
}
var newName = SyntaxFactory.CreateString(
new [] { childName.SegmentValues[1].Substring(1) }.Concat(childName.SegmentValues.Skip(2)),
childName.Expressions.Skip(1));
return(newName);
}
case StringSyntax parentString:
{
if (TryGetReplacementStringSyntax(parentString, childName, parentResourceSymbol) is not {
} newName)
{
return(null);
}
return(newName);
}
}
return(null);
}
public SyntaxBase?TryGetReplacementStringSyntax(StringSyntax parent, StringSyntax child, ResourceSymbol parentResourceSymbol)
{
if (parent.SegmentValues.Length > child.SegmentValues.Length ||
parent.Expressions.Length > child.Expressions.Length)
{
return(null);
}
for (var i = 0; i < parent.Expressions.Length; i++)
{
var childSymbol = semanticModel.GetSymbolInfo(child.Expressions[i]);
var parentSymbol = semanticModel.GetSymbolInfo(parent.Expressions[i]);
if (childSymbol == null || childSymbol != parentSymbol)
{
return(null);
}
}
for (var i = 0; i < parent.SegmentValues.Length - 1; i++)
{
if (child.SegmentValues[i] != parent.SegmentValues[i])
{
return(null);
}
}
var finalIndex = parent.SegmentValues.Length - 1;
if (!child.SegmentValues[finalIndex].StartsWith(parent.SegmentValues[finalIndex], StringComparison.Ordinal))
{
return(null);
}
var finalSegmentSuffix = child.SegmentValues[finalIndex].Substring(parent.SegmentValues[finalIndex].Length);
if (finalSegmentSuffix.Length == 0 || finalSegmentSuffix[0] != '/')
{
return(null);
}
var newNameValues = new [] { finalSegmentSuffix.Substring(1) }.Concat(child.SegmentValues.Skip(finalIndex + 1)).ToArray();
var newExpressions = child.Expressions.Skip(finalIndex).ToArray();
if (newNameValues.Length == 2 && newNameValues[0] == "" && newNameValues[1] == "")
{
// return "expr" rather than "'${expr}'"
return(newExpressions[0]);
}
return(SyntaxFactory.CreateString(newNameValues, newExpressions));
}
private static ResourceTypeReference?TryGetTypeReference(ResourceSymbol resourceSymbol) => resourceSymbol.Type switch
{
public LanguageExpression GetResourceNameExpression(ResourceSymbol resourceSymbol)
{
return(converter.GetResourceNameExpression(resourceSymbol));
}
private TypeSymbol GetResourceType(VariableAccessSyntax syntax, ResourceSymbol resource)
{
// resource bodies can participate in cycles
// need to explicitly force a type check on the body
return(HandleSymbolType(syntax.Name.IdentifierName, syntax.Name.Span, resource));
}
