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; }