/// <summary>Called when the visitor visits a NamespaceDeclarationSyntax node.</summary>
public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
{
var u = _namespaces.Select(each => SyntaxFactory.UsingDirective(SyntaxFactory.ParseName($" {each}"))
.WithLeadingTrivia(_leadingTrivia)
.WithTrailingTrivia(_trailingTrivia)
);
if (node.Name != null && node.Name.GetType() == typeof(QualifiedNameSyntax))
{
var currUsings = new List <string>();
var currNode = ((QualifiedNameSyntax)node.Name);
while (true)
{
currUsings.Add(currNode.ToString());
if (currNode.Left == null || currNode.Left.GetType() != typeof(QualifiedNameSyntax))
{
break;
}
currNode = (QualifiedNameSyntax)currNode.Left;
}
u = u.Where(uName => !currUsings.Contains(uName.Name.ToString()));
}
node = node.AddUsings(u.ToArray());
node = node.WithUsings(Sort(node.Usings));
return(base.VisitNamespaceDeclaration(node));
}
/// <summary>
/// Start code generation
/// </summary>
public void GenerateIntermediateCode()
{
if (Module == null)
{
throw new DataException("Please set Module before calling GenerateIntermediateCode()");
}
StandardFunctionRepository.Initialize(Module);
_compiledCode = SyntaxFactory.CompilationUnit();
MainClassNamespace = "Oberon0." + Module.Name;
MainClassName = Module.Name + "__Impl";
// Create a namespace: (namespace CodeGenerationSample)
_namespace = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(MainClassNamespace))
.NormalizeWhitespace();
// Add System using statement: (using System)
_namespace = _namespace.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System")),
SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("AnyClone")));
GenerateClass();
_namespace = _namespace.AddMembers(_classDeclaration);
_compiledCode = _compiledCode.AddMembers(_namespace).NormalizeWhitespace();
}
internal static NamespaceDeclarationSyntax AddUsing(this NamespaceDeclarationSyntax namespaceDeclaration, string fullName,
SyntaxTriviaList leadingTrivia)
{
return(namespaceDeclaration.AddUsings(
UsingDirective(ConstructNameSyntax("System.Threading.Tasks"))
.WithUsingKeyword(Token(leadingTrivia, SyntaxKind.UsingKeyword, TriviaList(Space)))
.WithSemicolonToken(Token(TriviaList(), SyntaxKind.SemicolonToken, TriviaList(LineFeed)))
));
}
public static NamespaceDeclarationSyntax AddUsings(this NamespaceDeclarationSyntax namespaceDeclarationSyntax, params string[] usings)
{
foreach (var usingName in usings)
{
var name = SyntaxFactory.ParseName(usingName);
var usingSyntax = SyntaxFactory.UsingDirective(name);
namespaceDeclarationSyntax = namespaceDeclarationSyntax.AddUsings(usingSyntax);
}
return(namespaceDeclarationSyntax);
}
/// <summary>Called when the visitor visits a NamespaceDeclarationSyntax node.</summary>
public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
{
var u = _namespaces.Select(each => SyntaxFactory.UsingDirective(SyntaxFactory.ParseName($" {each}"))
.WithLeadingTrivia(_leadingTrivia)
.WithTrailingTrivia(_trailingTrivia)
).ToArray();
node = node.AddUsings(u);
node = node.WithUsings(Sort(node.Usings));
return(base.VisitNamespaceDeclaration(node));
}
/// <summary> Create the namespace that contains the class(es). In this function, the usings are also created. </summary>
private static NamespaceDeclarationSyntax CreateNamespaceDeclarationSyntax(string namespaceName, string[] usings)
{
// Create a namespace: (namespace CodeGenerationSample)
NamespaceDeclarationSyntax @namespace = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(namespaceName)).NormalizeWhitespace();
// Add System using statement: (using System)
List <UsingDirectiveSyntax> usingDirectiveSyntaxes = CreateUsingDirectiveSyntaxes(usings);
for (int i = 0; i < usingDirectiveSyntaxes.Count; i++)
{
@namespace = @namespace.AddUsings(usingDirectiveSyntaxes[i]);
}
return(@namespace);
}
private static NamespaceDeclarationSyntax EmitUsingStatements(NamespaceDeclarationSyntax namespaceDeclaration, ISet <string> emittedUsings, IEnumerable <UsingDirectiveSyntax> usings)
{
foreach (var usingDirective in usings)
{
var fullString = usingDirective.NormalizeWhitespace().ToFullString();
if (emittedUsings.Add(fullString))
{
if (usingDirective.Name is IdentifierNameSyntax ins && ins.Identifier.ValueText.StartsWith("<global", StringComparison.OrdinalIgnoreCase))
{
continue;
}
namespaceDeclaration = namespaceDeclaration.AddUsings(usingDirective);
}
}
return(namespaceDeclaration);
}
private static GenerationResult Generate(SemanticModel sourceModel, SyntaxNode sourceSymbol, bool withRegeneration, IUnitTestGeneratorOptions options, NamespaceDeclarationSyntax targetNamespace, HashSet <string> usingsEmitted, CompilationUnitSyntax compilation, NamespaceDeclarationSyntax originalTargetNamespace)
{
var frameworkSet = FrameworkSetFactory.Create(options);
var typeParametersEmitted = new HashSet <string>();
var model = new TestableItemExtractor(sourceModel.SyntaxTree, sourceModel);
var classModels = model.Extract(sourceSymbol).ToList();
foreach (var c in classModels)
{
if (c.Declaration.Parent is NamespaceDeclarationSyntax namespaceDeclaration)
{
targetNamespace = EmitUsingStatements(targetNamespace, usingsEmitted, SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(namespaceDeclaration.Name.ToString())));
}
}
foreach (var classModel in classModels)
{
var targetType = GetOrCreateTargetType(sourceSymbol, targetNamespace, frameworkSet, classModel, out var originalTargetType);
targetNamespace = AddTypeParameterAliases(classModel, typeParametersEmitted, targetNamespace);
targetType = ApplyStrategies(withRegeneration, targetType, frameworkSet, classModel);
targetNamespace = AddTypeToTargetNamespace(originalTargetType, targetNamespace, targetType);
foreach (var parameter in frameworkSet.Context.GenericTypes)
{
targetNamespace = targetNamespace.AddUsings(
SyntaxFactory.UsingDirective(SyntaxFactory.QualifiedName(SyntaxFactory.IdentifierName(Strings.UnitTestGenerator_AddUsingStatements_System), SyntaxFactory.IdentifierName("String")))
.WithAlias(SyntaxFactory.NameEquals(SyntaxFactory.IdentifierName(parameter))));
}
}
targetNamespace = AddUsingStatements(targetNamespace, usingsEmitted, frameworkSet, classModels);
compilation = AddTargetNamespaceToCompilation(originalTargetNamespace, compilation, targetNamespace);
var generationResult = CreateGenerationResult(compilation, classModels);
AddAssembliesToGenerationResult(sourceModel, frameworkSet, generationResult);
return(generationResult);
}
public CSharpSyntaxNode Convert(SourceFile sourceFile)
{
CompilationUnitSyntax csCompilationUnit = SyntaxFactory.CompilationUnit();
foreach (string us in this.Context.Config.Usings)
{
csCompilationUnit = csCompilationUnit.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(us)));
}
csCompilationUnit = csCompilationUnit.AddMembers(sourceFile.MouduleDeclarations.ToCsNodes <MemberDeclarationSyntax>());
foreach (Node import in sourceFile.ImportDeclarations)
{
foreach (UsingDirectiveSyntax usingSyntax in import.ToCsNode <SyntaxList <UsingDirectiveSyntax> >())
{
csCompilationUnit = csCompilationUnit.AddUsings(usingSyntax);
}
}
List <Node> typeAliases = sourceFile.TypeAliases;
List <Node> typeDefinitions = this.FilterTypes(sourceFile.TypeDefinitions);
if (typeAliases.Count > 0 || typeDefinitions.Count > 0)
{
string ns = sourceFile.Document.GetPackageName();
if (!string.IsNullOrEmpty(ns))
{
NamespaceDeclarationSyntax nsSyntaxNode = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(ns));
nsSyntaxNode = nsSyntaxNode
.AddUsings(typeAliases.ToCsNodes <UsingDirectiveSyntax>())
.AddMembers(typeDefinitions.ToCsNodes <MemberDeclarationSyntax>());
csCompilationUnit = csCompilationUnit.AddMembers(nsSyntaxNode);
}
else
{
csCompilationUnit = csCompilationUnit
.AddUsings(typeAliases.ToCsNodes <UsingDirectiveSyntax>())
.AddMembers(typeDefinitions.ToCsNodes <MemberDeclarationSyntax>());
}
}
return(csCompilationUnit);
}
private static NamespaceDeclarationSyntax AddTypeParameterAliases(ClassModel classModel, HashSet <string> typeParametersEmitted, NamespaceDeclarationSyntax targetNamespace)
{
foreach (var parameter in classModel.Declaration.TypeParameterList?.Parameters ?? Enumerable.Empty <TypeParameterSyntax>())
{
var aliasedName = parameter.Identifier.ToString();
if (targetNamespace.DescendantNodes().OfType <UsingDirectiveSyntax>().Any(node => string.Equals(node.Alias?.Name?.ToString(), aliasedName, StringComparison.OrdinalIgnoreCase)))
{
continue;
}
if (typeParametersEmitted.Add(parameter.Identifier.ValueText))
{
targetNamespace = targetNamespace.AddUsings(
SyntaxFactory.UsingDirective(SyntaxFactory.QualifiedName(SyntaxFactory.IdentifierName(Strings.UnitTestGenerator_AddUsingStatements_System), SyntaxFactory.IdentifierName("String")))
.WithAlias(SyntaxFactory.NameEquals(SyntaxFactory.IdentifierName(parameter.Identifier))));
}
}
return(targetNamespace);
}
public CSharpSyntaxNode Convert(ModuleDeclaration module)
{
string ns = this.GetNamespace(module);
if (this.Context.Config.NamespaceMappings.ContainsKey(ns))
{
ns = this.Context.Config.NamespaceMappings[ns];
}
else if (!string.IsNullOrEmpty(this.Context.Config.Namespace))
{
ns = this.Context.Config.Namespace;
}
NamespaceDeclarationSyntax nsSyntax = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(ns));
ModuleBlock mb = module.GetModuleBlock();
if (mb != null)
{
nsSyntax = nsSyntax
.AddUsings(mb.TypeAliases.ToCsNodes <UsingDirectiveSyntax>())
.WithMembers(mb.ToCsNode <SyntaxList <MemberDeclarationSyntax> >());
}
return(nsSyntax);
}
private static void Main(string[] args)
{
string assemblyName = "cls" + Guid.NewGuid().ToString("N"); //Path.GetRandomFileName();
var sourceCode = CreateSourceCode(assemblyName);
SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(sourceCode);
var root = (CompilationUnitSyntax)syntaxTree.GetRoot();
NamespaceDeclarationSyntax namespaceDeclaration = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.IdentifierName(assemblyName));
var newCompilationUnit = SyntaxFactory.CompilationUnit()
.AddMembers
(
namespaceDeclaration
.AddUsings(root.Usings.ToArray())
.AddMembers(root.Members[0])
);
syntaxTree = SyntaxFactory.SyntaxTree(newCompilationUnit); //CSharpSyntaxTree.Create(newCompilationUnit);
var diagnostics = syntaxTree.GetDiagnostics().ToArray();
//if (root.Kind() == SyntaxKind.CompilationUnit)
//{
// CompilationUnitSyntax compilationUnit = (CompilationUnitSyntax) root;
// Do(compilationUnit.Members[0]);
//}
MetadataReference[] references =
{
MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location)
};
Compilation compilation = CSharpCompilation.Create
(
assemblyName: assemblyName,
syntaxTrees: new[] { syntaxTree },
references: references,
options: new CSharpCompilationOptions(OutputKind.ConsoleApplication /*, mainTypeName: assemblyName + ".Program", usings: new[] { "System" }*/)
);
byte[] bytes;
var result = Emit(compilation, out bytes);
if (result.Success)
{
Assembly assembly = Assembly.Load(/*ms.ToArray()*/ bytes);
//var appType = assembly.GetType("App .Program");
//var mainMethod = appType.GetMethod("Main", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy, null, new Type[0], null);
//var retVal = mainMethod.Invoke(null, null);
assembly.EntryPoint.Invoke(null, new object[] { new[] { Environment.CurrentDirectory } });
}
else
{
IEnumerable <Diagnostic> failures = result.Diagnostics.Where(diagnostic =>
diagnostic.IsWarningAsError ||
diagnostic.Severity == DiagnosticSeverity.Error);
foreach (Diagnostic diagnostic in failures)
{
switch (diagnostic.Location.Kind)
{
case LocationKind.SourceFile:
case LocationKind.XmlFile:
case LocationKind.ExternalFile:
FileLinePositionSpan lineSpan = diagnostic.Location.GetLineSpan();
FileLinePositionSpan mappedLineSpan = diagnostic.Location.GetMappedLineSpan();
if (lineSpan.IsValid && mappedLineSpan.IsValid)
{
string path;
string basePath;
if (mappedLineSpan.HasMappedPath)
{
path = mappedLineSpan.Path;
basePath = lineSpan.Path;
}
else
{
path = lineSpan.Path;
basePath = (string)null;
}
//return string.Format(formatter, "{0}{1}: {2}: {3}", (object)this.FormatSourcePath(path, basePath, formatter), (object)this.FormatSourceSpan(mappedLineSpan.Span, formatter), (object)this.GetMessagePrefix(diagnostic), (object)diagnostic.GetMessage((IFormatProvider)cultureInfo));
}
break;
}
Location location = diagnostic.Location;
LinePosition startPosition = location.GetMappedLineSpan().Span.Start;
TextSpan sourceSpan = location.SourceSpan;
var location1 = location.SourceTree.GetLineSpan(sourceSpan);
var sourceText = location.SourceTree.GetText().Lines.GetLineFromPosition(location.SourceSpan.Start).ToString().Substring(8, 7);
Console.Error.WriteLine($"({startPosition.Line + 1},{startPosition.Character + 1}) {diagnostic.Id} : {diagnostic.GetMessage()}");
}
}
}
