private static async Task AddGeneratedObjectCodeAsync(
ConnectedServiceHandlerContext context,
Project project,
SalesforceConnectedServiceInstance salesforceInstance,
GeneratedService generatedService,
string modelsHintPath)
{
await context.Logger.WriteMessageAsync(LoggerMessageCategory.Information, Resources.LogMessage_BuildingObjectModel);
IEnumerable <GeneratedObject> generatedObjects = await CodeModelBuilder.BuildObjectModelAsync(
salesforceInstance.SelectedObjects,
salesforceInstance.DesignTimeAuthentication,
generatedService,
context.Logger);
await context.Logger.WriteMessageAsync(LoggerMessageCategory.Information, Resources.LogMessage_AddingGeneratedCodeForObjects, generatedObjects.Count());
await GeneratedCodeHelper.AddGeneratedCodeAsync(
context,
project,
"SalesforceObject",
modelsHintPath,
(host) => SalesforceConnectedServiceHandler.GetObjectT4Sessions(host, generatedObjects),
() => new SalesforceObject(),
(session) => ((GeneratedObject)session["generatedObject"]).Model.Name);
}
public OperationReader(CodeModelBuilder codeModel, IFunctionContext destination, SyntaxNode syntax)
{
_codeModel = codeModel;
_destination = destination;
_syntax = syntax;
_semanticModel = _codeModel.GetSemanticModel(syntax);
}
public static ConstantExpression ReadTypedConstant(CodeModelBuilder model, TypedConstant constant)
{
return(new ConstantExpression {
Type = model.TryGetMember <TypeMember>(constant.Type),
Value = constant.Value
});
}
private (ClassReader, CodeModelBuilder) GetClassReaderFromCode(
string csharpCode,
string className,
Func <INamedTypeSymbol, INamedTypeSymbol> walkSymbols = null,
Action <List <IPhasedTypeReader> > setupAllReaders = null)
{
var compilation = TestWorkspaceFactory.CompileCodeOrThrow(
csharpCode,
references: new[] {
this.GetType().Assembly.Location
});
var originSymbol = compilation.GetTypeByMetadataName(className);
var typeSymbol = walkSymbols?.Invoke(originSymbol) ?? originSymbol;
typeSymbol.ShouldNotBeNull($"Type symbol '{className}' could not be found in compilation.");
var modelBuilder = new CodeModelBuilder(compilation);
var allReaders = new List <IPhasedTypeReader>();
var discoveryVisitor = new TypeDiscoverySymbolVisitor(modelBuilder, allReaders);
var readerContext = new CodeReaderContext(modelBuilder.GetCodeModel(), null, LanguageInfo.Entries.CSharp());
compilation.GlobalNamespace.Accept(discoveryVisitor);
setupAllReaders?.Invoke(allReaders);
var reader = allReaders.OfType <ClassReader>().FirstOrDefault(r => r.TypeSymbol.Equals(typeSymbol));
reader.ShouldNotBeNull($"ClassReader for '{className}' was not registered.");
allReaders.ForEach(r => r.RegisterProxy());
return(reader, modelBuilder);
}
public static void ReadBody(CodeModelBuilder model, IMethodSymbol symbol, IFunctionContext destination)
{
var syntax = symbol.DeclaringSyntaxReferences
.Select(syntaxRef => syntaxRef.GetSyntax())
.FirstOrDefault(node => node is BaseMethodDeclarationSyntax || node is ArrowExpressionClauseSyntax);
if (syntax != null)
{
var reader = new OperationReader(model, destination, syntax);
reader.ReadMethodBody();
// destination.Body = new BlockStatement();
//
// if (syntax.ExpressionBody != null)
// {
// destination.Body.Statements.Add(new ReturnStatement {
// Expression = ExpressionReader.ReadExpression(model, syntax.ExpressionBody.Expression)
// });
// }
// else if (syntax.Body != null)
// {
// foreach (var statementSyntax in syntax.Body.Statements)
// {
// destination.Body.Statements.Add(StatementReader.ReadStatement(model, statementSyntax));
// }
// }
}
}
public void Write(string path, CodeModelBuilder modelBuilder)
{
var exporter = new DgmlExporter();
using (var stream = File.Create(path))
{
exporter.Export(modelBuilder.Model, stream);
}
}
public MutatorStepDescriptor(CodeModelBuilder modelBuilder, Type type)
{
this.Type = type;
this.Provides = modelBuilder.GetProvidedResources(type);
this.Needs = modelBuilder.GetNeededResources(type);
this.OptionalNeeds = modelBuilder.GetOptionalNeeds(type);
}
public static MethodReader CreateAccessorMethodReader(CodeModelBuilder modelBuilder, IMethodSymbol accessorSymbol)
{
if (accessorSymbol != null)
{
var reader = new MethodReader(modelBuilder, accessorSymbol);
reader.ReadDeclaration();
return(reader);
}
return(null);
}
public static AbstractStatement ReadStatement(CodeModelBuilder model, StatementSyntax statement)
{
if (ReaderBySyntaxType.TryGetValue(statement.GetType(), out var reader))
{
return(reader(model, statement));
}
else
{
throw new NotSupportedException(
$"Statement of type '{statement.GetType().Name}' is not supported by {nameof(StatementReader)}.");
}
}
public StepDescriptor(CodeModelBuilder modelBuilder, Type type)
{
this.Type = type;
this.Provides = modelBuilder.GetProvidedResources(type);
this.Needs = modelBuilder.GetNeededResources(type);
this.OptionalNeeds = modelBuilder.GetOptionalNeeds(type);
this.IsRule = typeof(IRule).IsAssignableFrom(this.Type);
this.IsMutator = typeof(IMutator).IsAssignableFrom(this.Type);
}
public void ShouldAnnonateImmutableTypes()
{
// arrange
var builder = new CodeModelBuilder();
builder.RegisterConventionsFrom(TestTarget.Conventions.Marker.Assembly);
builder.Model.AddNode(new TypeNode(typeof (SetPropertyInCtor)));
// act
builder.RunMutator<AnnonateImmutableTypes>();
// assert
Assert.That(builder.Model, Graph.Has
.NodeForType<SetPropertyInCtor>(Annonated.With<Immutable>()));
}
private RunList<StepDescriptor> BuildRunlist(CodeModelBuilder modelBuilder, string[] finalResources)
{
var mutators = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(x => x.GetTypes())
.Where(x => typeof(IMutator).IsAssignableFrom(x) && x.IsClass && !x.IsAbstract)
.Select(x => new MutatorStepDescriptor(modelBuilder, x));
var finalResourcesStep = new RequiredResources(finalResources);
var dependencyNetwork = new DependencyManager<StepDescriptor>(x => x.Provides, x => x.Needs, x => x.OptionalNeeds);
dependencyNetwork.AddRange(mutators);
dependencyNetwork.Add(finalResourcesStep);
dependencyNetwork.RequireElements(finalResourcesStep);
return dependencyNetwork.CalculateRunList();
}
public static AttributeDescription ReadAttribute(CodeModelBuilder modelBuilder, AttributeData data)
{
var constructorArguments = data.ConstructorArguments
.Select(arg => ExpressionReader.ReadTypedConstant(modelBuilder, arg))
.ToList <AbstractExpression>();
var propertyValues = data.NamedArguments
.Select(kvp => new NamedPropertyValue(kvp.Key, ExpressionReader.ReadTypedConstant(modelBuilder, kvp.Value)))
.ToList();
var result = new AttributeDescription {
AttributeType = modelBuilder.TryGetMember <TypeMember>(data.AttributeClass),
ConstructorArguments = constructorArguments,
PropertyValues = propertyValues
};
return(result);
}
private void BuildCodeModel()
{
CodeModelBuilder codeModelBuilder = new CodeModelBuilder(options, this);
CodeModelValidator codeModelValidator = new CodeModelValidator(this);
CodeModelProcessor validationProcessor = new CodeModelProcessor(codeModelValidator, options);
foreach (IStreamSource source in options.Sources)
{
CompilationUnitNode compilationUnit = codeModelBuilder.BuildCodeModel(source);
if (compilationUnit != null)
{
validationProcessor.Process(compilationUnit);
compilationUnitList.Add(compilationUnit);
}
}
}
public TypeReaderMechanism(CodeModelBuilder modelBuilder, INamedTypeSymbol symbol, string fullyQualifiedMetadataName)
{
this.ModelBuilder = modelBuilder;
this.Symbol = symbol;
this.FullyQualifiedMetadataName = fullyQualifiedMetadataName;
this.ClrType = Type.GetType(FullyQualifiedMetadataName, throwOnError: false);
this.MemberBuilder = new TypeMember();
MemberBuilder.Status = MemberStatus.Incomplete;
MemberBuilder.Modifier = symbol.GetMemberModifier();
MemberBuilder.Bindings.Add(Symbol);
MemberBuilder.Bindings.Add(FullyQualifiedMetadataName);
MemberBuilder.Bindings.Add(new SystemTypeNameBinding(Symbol.GetSystemTypeMetadataName()));
if (ClrType != null)
{
MemberBuilder.Bindings.Add(ClrType);
}
AssignAssemblyAndModuleName();
}
private void BuildCodeModel()
{
CodeModelBuilder codeModelBuilder = new CodeModelBuilder(options, this);
CodeModelValidator codeModelValidator = new CodeModelValidator(this);
CodeModelProcessor validationProcessor = new CodeModelProcessor(codeModelValidator, options);
compilation = GetPreprocessedCompilation();
IEnumerable <IStreamSource> sources = options.Sources.Select(s => GetPreprocessedSource(compilation, s));
foreach (IStreamSource source in sources)
{
CompilationUnitNode compilationUnit = codeModelBuilder.BuildCodeModel(source);
if (compilationUnit != null)
{
validationProcessor.Process(compilationUnit);
compilationUnitList.Add(compilationUnit);
}
}
}
public async Task Execute(Solution solution, IList <TemplateToRender> templates)
{
await status.Update("Rendering", 0, templates.Count);
for (int i = 0; i < templates.Count; ++i)
{
var template = templates[i];
output.Info(new String('-', 69));
output.Info("Rendering started : " + System.IO.Path.GetFileName(template.FilePath));
await status.Update("Rendering", i + 1, templates.Count);
var userCodeLoader = new UserCodeLoader(output, fileSearcher);
var userCode = await userCodeLoader.LoadUserCodeForGivenProject(solution, template.ProjectPath).ConfigureAwait(false);
var editorConfig = new EditorConfig(userCode.Config);
var codeModelBuilder = new CodeModelBuilder();
var codeModel = new LazyCodeModel(() => codeModelBuilder.Build(solution, editorConfig));
output.Info($"Loading template : {template.FilePath}");
var templateContent = template.Content ?? await fileReaderWriter.Read(template.FilePath).ConfigureAwait(false);
var templateRenderer = new TemplateRenderer(errorList, output);
var renderedItems = await templateRenderer.RenderAsync(template.FilePath, templateContent, codeModel, userCode.TypesThatMayContainCustomFunctions, editorConfig).ConfigureAwait(false);
var fileSaver = new FileSaver(output, sourceControl, fileReaderWriter);
await fileSaver.Save(renderedItems).ConfigureAwait(false);
if (editorConfig.AddGeneratedFilesToVSProject)
{
output.Info("Updating VisualStudio solution");
await solutionItemsManager.UpdateSolution(template.FilePath, renderedItems.Select(x => x.FilePath)).ConfigureAwait(false);
output.Info("VisualStudio solution updated successfully");
}
await status.Update("Rendering succeed");
}
}
public void ExportToDgml()
{
var builder = new CodeModelBuilder();
builder.RegisterConventionsFrom(typeof(TestTarget.Conventions.Marker).Assembly);
builder.RunMutator(new AddAssemblies(typeof(Marker).Assembly));
builder.RunMutator<AddTypes>();
builder.RunMutator(new AddMethods(AddMethods.DefaultFlags | BindingFlags.NonPublic));
builder.RunMutator<AddProperties>();
builder.RunMutator<AddFields>();
builder.RunMutator<DetectEntities>();
builder.RunMutator<LinkMethodCalls>();
builder.RunMutator<LinkFieldAccess>();
builder.RunMutator<LinkPropertyAccess>();
builder.RunMutator<DetectApplyEvent>();
builder.RunMutator<DetectApplyEventMethods>();
var exporter = new DgmlExporter
{
CategoryStyles =
{
new CategoryStyle {Target = typeof (TypeNode), Background = "#999933"},
new CategoryStyle {Target = typeof (MethodNode), Background = "LightGreen"},
new CategoryStyle {Target = typeof (PropertyNode), Background = "Yellow"},
new CategoryStyle {Target = typeof (FieldNode), Background = "#993300"},
new CategoryStyle {Target = typeof (ApplyEventMethod), Background = "Red"},
new CategoryStyle {Target = typeof(ApplyEventLink), Stroke = "#FF11FFBB"}
}
};
using (var output = File.Create(Path.Combine(TestContext.CurrentContext.WorkDirectory, "graph.dgml")))
{
exporter.Export(builder.Model, output);
}
}
public void HowToUse()
{
// arrange
var compilation = CompileCode(@"
namespace NS1 {
class C1 { }
}
");
var modelBuilder = new CodeModelBuilder(compilation);
var discoveredTypeReaders = new List <IPhasedTypeReader>();
// act
var visitor = new TypeDiscoverySymbolVisitor(modelBuilder, discoveredTypeReaders);
compilation.GlobalNamespace.Accept(visitor);
// assert
var discoveredTypeNames = discoveredTypeReaders.Select(r => r.TypeSymbol.Name);
}
public TypeDiscoverySymbolVisitor(CodeModelBuilder modelBuilder, List <IPhasedTypeReader> results)
{
_modelBuilder = modelBuilder;
_results = results;
}
public void Setup()
{
this.Builder = new CodeModelBuilder();
}
public static IEnumerable <AttributeDescription> ReadSymbolAttributes(CodeModelBuilder modelBuilder, ISymbol symbol)
{
return(symbol
.GetAttributes()
.Select(attr => AttributeReader.ReadAttribute(modelBuilder, attr)));
}
public FieldReader(CodeModelBuilder modelBuilder, IFieldSymbol symbol)
{
_modelBuilder = modelBuilder;
_symbol = symbol;
_member = null;
}
private void BuildModel()
{
Log.Info("Building model");
this.modelBuilder = new CodeModelBuilder();
this.modelBuilder.RegisterConventionsFrom(this.conventionAssemblies.ToArray());
Log.Trace("Adding assemblies to model");
this.modelBuilder.RunMutator(new AddAssemblies(this.assembliesToAnalyze));
var enabledRules = this.toolkitAssemblies
.SelectMany(x => x.GetTypes())
.Where(x => typeof(IRule).IsAssignableFrom(x) && x.IsClass && !x.IsAbstract)
.Where(x => !this.config.DisabledRules.Contains(x.Name))
.ToList();
Log.Info("Enabled rules: {0}", string.Join(", ", enabledRules.Select(x => x.Name)));
var mutators = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(x => x.GetTypes())
.Where(x => typeof(IMutator).IsAssignableFrom(x) && x.IsClass && !x.IsAbstract)
.Select(x => new StepDescriptor(this.modelBuilder, x));
var rules = enabledRules
.Select(x => new StepDescriptor(this.modelBuilder, x))
.ToList();
Log.Info("Determining runlist");
try
{
this.runlist = DetermineRunList(mutators, rules);
}
catch (NeedsNotSatisfiedException e)
{
Log.Error("Missing resources: {0}", e.MissingResource);
throw;
}
catch (UnableToBuildRunListException e)
{
Log.Error("Unable to build runlist {0}", e.InnerException.Message);
throw;
}
this.Report.RunList(runlist);
Log.Info("Order: {0}", string.Join(", ", runlist.Elements));
foreach (var mutatorType in this.runlist.Elements.Where(x => x.IsMutator))
{
Log.Debug("Running mutator {0}", mutatorType);
this.modelBuilder.RunMutator(mutatorType.Type);
}
}
private static AbstractStatement ReadExpression(CodeModelBuilder model, ExpressionStatementSyntax syntax)
{
return(new ExpressionStatement {
Expression = ExpressionReader.ReadExpression(model, syntax.Expression)
});
}
public PropertyReader(CodeModelBuilder modelBuilder, IPropertySymbol symbol)
{
_modelBuilder = modelBuilder;
_symbol = symbol;
_member = null;
}
public void RunFinished(CodeModelBuilder modelBuilder)
{
this.reportModel.NodesCountByType = modelBuilder.Model.Nodes.GroupBy(x => x.GetType()).ToDictionary(x => x.Key, x => x.Count());
this.reportModel.LinksCountByType = modelBuilder.Model.Links.GroupBy(x => x.GetType()).ToDictionary(x => x.Key, x => x.Count());
}
public static MethodSignature ReadSignature(CodeModelBuilder modelBuilder, IMethodSymbol symbol)
{
return(ReadSignature(modelBuilder.GetCodeModel(), symbol));
}
public MethodReader(CodeModelBuilder modelBuilder, IMethodSymbol symbol)
{
_modelBuilder = modelBuilder;
_symbol = symbol;
_member = null;
}
public void SetUp()
{
this.Builder = new CodeModelBuilder();
this.Builder.RegisterConventionsFrom(typeof(TestTarget.Conventions.Marker).Assembly);
}
public EventReader(CodeModelBuilder modelBuilder, IEventSymbol symbol)
{
_modelBuilder = modelBuilder;
_symbol = symbol;
_member = null;
}
private CodeModelBuilder SetUpCodeModelBuilder()
{
var modelBuilder = new CodeModelBuilder();
foreach (var assembly in this.config.ConventionAssemblies)
{
modelBuilder.RegisterConventionsFrom(Assembly.LoadFrom(assembly));
}
foreach (var assembly in this.config.AssembliesToAnalyze)
{
modelBuilder.RunMutator(new AddAssemblies(Assembly.LoadFrom(assembly)));
}
return modelBuilder;
}
