private static Uri?GetFileUriWithDiagnostics(IBinder binder, IFileResolver fileResolver, IDiagnosticWriter diagnostics, string filePath, SyntaxBase filePathArgument)
{
if (!LocalModuleReference.Validate(filePath, out var validateFilePathFailureBuilder))
{
diagnostics.Write(validateFilePathFailureBuilder.Invoke(DiagnosticBuilder.ForPosition(filePathArgument)));
return(null);
}
var fileUri = fileResolver.TryResolveFilePath(binder.FileSymbol.FileUri, filePath);
if (fileUri is null)
{
diagnostics.Write(DiagnosticBuilder.ForPosition(filePathArgument).FilePathCouldNotBeResolved(filePath, binder.FileSymbol.FileUri.LocalPath));
return(null);
}
if (!fileUri.IsFile)
{
diagnostics.Write(DiagnosticBuilder.ForPosition(filePathArgument).UnableToLoadNonFileUri(fileUri));
return(null);
}
return(fileUri);
}
public (Uri entrypointUri, ImmutableDictionary <Uri, string> filesToSave) DecompileFileWithModules(Uri entryJsonUri, Uri entryBicepUri)
{
var workspace = new Workspace();
var decompileQueue = new Queue <(Uri, Uri)>();
decompileQueue.Enqueue((entryJsonUri, entryBicepUri));
while (decompileQueue.Count > 0)
{
var(jsonUri, bicepUri) = decompileQueue.Dequeue();
if (PathHelper.HasBicepExtension(jsonUri))
{
throw new InvalidOperationException($"Cannot decompile the file with .bicep extension: {jsonUri}.");
}
if (workspace.TryGetSourceFile(bicepUri, out _))
{
continue;
}
if (!fileResolver.TryRead(jsonUri, out var jsonInput, out _))
{
throw new InvalidOperationException($"Failed to read {jsonUri}");
}
var(program, jsonTemplateUrisByModule) = TemplateConverter.DecompileTemplate(workspace, fileResolver, bicepUri, jsonInput);
var bicepFile = SourceFileFactory.CreateBicepFile(bicepUri, program.ToText());
workspace.UpsertSourceFile(bicepFile);
foreach (var module in program.Children.OfType <ModuleDeclarationSyntax>())
{
var moduleRelativePath = SyntaxHelper.TryGetModulePath(module, out _);
if (moduleRelativePath == null ||
!LocalModuleReference.Validate(moduleRelativePath, out _) ||
!Uri.TryCreate(bicepUri, moduleRelativePath, out var moduleUri))
{
// Do our best, but keep going if we fail to resolve a module file
continue;
}
if (!workspace.TryGetSourceFile(moduleUri, out _) && jsonTemplateUrisByModule.TryGetValue(module, out var linkedTemplateUri))
{
decompileQueue.Enqueue((linkedTemplateUri, moduleUri));
}
}
}
RewriteSyntax(workspace, entryBicepUri, semanticModel => new ParentChildResourceNameRewriter(semanticModel));
RewriteSyntax(workspace, entryBicepUri, semanticModel => new DependsOnRemovalRewriter(semanticModel));
RewriteSyntax(workspace, entryBicepUri, semanticModel => new ForExpressionSimplifierRewriter(semanticModel));
for (var i = 0; i < 5; i++)
{
// This is a little weird. If there are casing issues nested inside casing issues (e.g. in an object), then the inner casing issue will have no type information
// available, as the compilation will not have associated a type with it (since there was no match on the outer object). So we need to correct the outer issue first,
// and then move to the inner one. We need to recompute the entire compilation to do this. It feels simpler to just do this in passes over the file, rather than on demand.
if (!RewriteSyntax(workspace, entryBicepUri, semanticModel => new TypeCasingFixerRewriter(semanticModel)))
{
break;
}
}
return(entryBicepUri, PrintFiles(workspace));
}
