private async Task<ImmutableArray<TaggedText>> TryAddSnippetInvocationPart( Document document, CompletionItem item, ImmutableArray<TaggedText> parts, CancellationToken cancellationToken) { var languageServices = document.Project.LanguageServices; var snippetService = languageServices.GetService<ISnippetInfoService>(); if (snippetService != null) { var change = await GetTextChangeAsync(document, item, ch: '\t', cancellationToken: cancellationToken).ConfigureAwait(false) ?? new TextChange(item.Span, item.DisplayText); var insertionText = change.NewText; if (snippetService != null && snippetService.SnippetShortcutExists_NonBlocking(insertionText)) { var note = string.Format(FeaturesResources.Note_colon_Tab_twice_to_insert_the_0_snippet, insertionText); if (parts.Any()) { parts = parts.Add(new TaggedText(TextTags.LineBreak, Environment.NewLine)); } parts = parts.Add(new TaggedText(TextTags.Text, note)); } } return parts; }
public static CompletionItem Create( string displayText, TextSpan span, Glyph? glyph = null, ImmutableArray<SymbolDisplayPart> description = default(ImmutableArray<SymbolDisplayPart>), string sortText = null, string filterText = null, bool preselect = false, bool showsWarningIcon = false, bool shouldFormatOnCommit = false, bool isArgumentName = false, ImmutableDictionary<string, string> properties = null, ImmutableArray<string> tags = default(ImmutableArray<string>), CompletionItemRules rules = null) { tags = tags.IsDefault ? ImmutableArray<string>.Empty : tags; if (glyph != null) { // put glyph tags first tags = GlyphTags.GetTags(glyph.Value).AddRange(tags); } if (showsWarningIcon) { tags = tags.Add(CompletionTags.Warning); } if (isArgumentName) { tags = tags.Add(CompletionTags.ArgumentName); } properties = properties ?? ImmutableDictionary<string, string>.Empty; if (!description.IsDefault && description.Length > 0) { properties = properties.Add("Description", EncodeDescription(description)); } rules = rules ?? CompletionItemRules.Default; rules = rules.WithPreselect(preselect) .WithFormatOnCommit(shouldFormatOnCommit); return CompletionItem.Create( displayText: displayText, filterText: filterText, sortText: sortText, span: span, properties: properties, tags: tags, rules: rules); }
protected virtual BoundStatement RewriteBlockStatement(BoundBlockStatement node) { ImmutableArray <BoundStatement> .Builder builder = null; for (var i = 0; i < node.Statements.Length; i++) { var oldStatement = node.Statements[i]; var newStatement = RewriteStatement(oldStatement); if (newStatement != oldStatement) { if (builder == null) { builder = ImmutableArray.CreateBuilder <BoundStatement>(node.Statements.Length); for (var j = 0; j < i; j++) { builder.Add(node.Statements[j]); } } } builder?.Add(newStatement); } return(builder == null ? node : new BoundBlockStatement(builder.MoveToImmutable())); }
protected virtual BoundExpression RewriteCallExpression(BoundCallExpression node) { ImmutableArray <BoundExpression> .Builder?builder = null; for (var i = 0; i < node.Arguments.Length; i++) { var oldArgument = node.Arguments[i]; var newArgument = RewriteExpression(oldArgument); if (newArgument != oldArgument) { if (builder == null) { builder = ImmutableArray.CreateBuilder <BoundExpression>(node.Arguments.Length); for (var j = 0; j < i; j++) { builder.Add(node.Arguments[j]); } } } builder?.Add(newArgument); } if (builder == null) { return(node); } return(new BoundCallExpression(node.Syntax, node.Function, builder.MoveToImmutable())); }
private void AddNode(ImmutableArray<NavInfoNode>.Builder builder, string name, uint type) { if (string.IsNullOrEmpty(name)) { return; } builder.Add(new NavInfoNode(name, type)); }
public static CompletionItem Create( string displayText, Glyph? glyph = null, ImmutableArray<SymbolDisplayPart> description = default(ImmutableArray<SymbolDisplayPart>), string sortText = null, string filterText = null, int? matchPriority = null, bool showsWarningIcon = false, bool shouldFormatOnCommit = false, ImmutableDictionary<string, string> properties = null, ImmutableArray<string> tags = default(ImmutableArray<string>), CompletionItemRules rules = null) { tags = tags.NullToEmpty(); if (glyph != null) { // put glyph tags first tags = GlyphTags.GetTags(glyph.Value).AddRange(tags); } if (showsWarningIcon) { tags = tags.Add(CompletionTags.Warning); } properties = properties ?? ImmutableDictionary<string, string>.Empty; if (!description.IsDefault && description.Length > 0) { properties = properties.Add("Description", EncodeDescription(description)); } rules = rules ?? CompletionItemRules.Default; rules = rules.WithMatchPriority(matchPriority.GetValueOrDefault()) .WithFormatOnCommit(shouldFormatOnCommit); return CompletionItem.Create( displayText: displayText, filterText: filterText, sortText: sortText, properties: properties, tags: tags, rules: rules); }
protected virtual BoundStatement RewriteBlockStatement(BoundStatement node) { ImmutableArray <BoundStatement> .Builder?builder = null; var boundStatements = node switch { BoundBlockStatement bbs => bbs.Statements, BoundMemberBlockStatement bmbs => bmbs.Statements, _ => throw new Exception($"Unexpected block statement type '{node.Kind}'."), }; for (var i = 0; i < boundStatements.Length; i++) { var oldStatement = boundStatements[i]; var newStatement = RewriteStatement(oldStatement); if (newStatement != oldStatement) { if (builder == null) { builder = ImmutableArray.CreateBuilder <BoundStatement>(boundStatements.Length); for (var j = 0; j < i; j++) { builder.Add(boundStatements[j]); } } } builder?.Add(newStatement); } if (builder == null) { return(node); } return(new BoundBlockStatement(node.Syntax, builder.MoveToImmutable())); }
static ReferenceFinders() { DefaultRenameReferenceFinders = ImmutableArray.Create( Constructor, Destructor, Event, ExplicitInterfaceMethod, Field, Label, LinkedFiles, Local, MethodTypeParameter, NamedType, Namespace, Operator, OrdinaryMethod, Parameter, Property, PropertyAccessor, RangeVariable, TypeParameter); DefaultReferenceFinders = DefaultRenameReferenceFinders.Add(ConstructorInitializer); }
private async Task <Project> UpdateDocumentsAsync( Project project, IEnumerable <TextDocumentState> existingTextDocumentStates, ChecksumCollection oldChecksums, ChecksumCollection newChecksums, Func <Solution, ImmutableArray <DocumentInfo>, Solution> addDocuments, Func <Solution, DocumentId, Solution> removeDocument) { using var olds = SharedPools.Default <HashSet <Checksum> >().GetPooledObject(); using var news = SharedPools.Default <HashSet <Checksum> >().GetPooledObject(); olds.Object.UnionWith(oldChecksums); news.Object.UnionWith(newChecksums); // remove documents that exist in both side olds.Object.ExceptWith(newChecksums); news.Object.ExceptWith(oldChecksums); var oldMap = await GetDocumentMapAsync(existingTextDocumentStates, olds.Object).ConfigureAwait(false); var newMap = await GetDocumentMapAsync(_assetProvider, news.Object).ConfigureAwait(false); // added document ImmutableArray <DocumentInfo> .Builder?lazyDocumentsToAdd = null; foreach (var(documentId, newDocumentChecksums) in newMap) { if (!oldMap.ContainsKey(documentId)) { lazyDocumentsToAdd ??= ImmutableArray.CreateBuilder <DocumentInfo>(); // we have new document added var documentInfo = await _assetProvider.CreateDocumentInfoAsync(newDocumentChecksums.Checksum, _cancellationToken).ConfigureAwait(false); lazyDocumentsToAdd.Add(documentInfo); } } if (lazyDocumentsToAdd != null) { project = addDocuments(project.Solution, lazyDocumentsToAdd.ToImmutable()).GetProject(project.Id) !; } // changed document foreach (var(documentId, newDocumentChecksums) in newMap) { if (!oldMap.TryGetValue(documentId, out var oldDocumentChecksums)) { continue; } Contract.ThrowIfTrue(oldDocumentChecksums.Checksum == newDocumentChecksums.Checksum); var document = project.GetDocument(documentId) ?? project.GetAdditionalDocument(documentId) ?? project.GetAnalyzerConfigDocument(documentId); Contract.ThrowIfNull(document); project = await UpdateDocumentAsync(document, oldDocumentChecksums, newDocumentChecksums).ConfigureAwait(false); } // removed document foreach (var(documentId, _) in oldMap) { if (!newMap.ContainsKey(documentId)) { // we have a document removed project = removeDocument(project.Solution, documentId).GetProject(project.Id) !; } } return(project); }
private static void AddKeyword(this ImmutableArray <SymbolDisplayPart> .Builder builder, string text) { builder.Add(SymbolDisplayPartFactory.Keyword(text)); }
//this runs as a glib idle handler so it can add/remove text editor markers //in order to to block the GUI thread, we batch them in UPDATE_COUNT bool IdleHandler() { if (cancellationToken.IsCancellationRequested) { return(false); } var editor = ext.Editor; if (editor == null) { return(false); } //clear the old results out at the same rate we add in the new ones for (int i = 0; oldMarkers > 0 && i < UPDATE_COUNT; i++) { if (cancellationToken.IsCancellationRequested) { return(false); } editor.RemoveMarker(ext.markers.Dequeue()); oldMarkers--; } //add in the new markers for (int i = 0; i < UPDATE_COUNT; i++) { if (!enumerator.MoveNext()) { ext.tasks = builder.ToImmutable(); ext.OnTasksUpdated(EventArgs.Empty); return(false); } if (cancellationToken.IsCancellationRequested) { return(false); } var currentResult = (Result)enumerator.Current; if (currentResult.InspectionMark != IssueMarker.None) { int start = currentResult.Region.Start; int end = currentResult.Region.End; if (start >= end) { continue; } if (currentResult.InspectionMark == IssueMarker.GrayOut) { var marker = TextMarkerFactory.CreateGenericTextSegmentMarker(editor, TextSegmentMarkerEffect.GrayOut, TextSegment.FromBounds(start, end)); marker.IsVisible = currentResult.Underline; marker.Tag = currentResult; editor.AddMarker(marker); ext.markers.Enqueue(marker); // editor.Parent.TextViewMargin.RemoveCachedLine (editor.GetLineByOffset (start)); // editor.Parent.QueueDraw (); } else { var effect = currentResult.InspectionMark == IssueMarker.DottedLine ? TextSegmentMarkerEffect.DottedLine : TextSegmentMarkerEffect.WavedLine; var marker = TextMarkerFactory.CreateGenericTextSegmentMarker(editor, effect, TextSegment.FromBounds(start, end)); marker.Color = GetColor(editor, currentResult); marker.IsVisible = currentResult.Underline; marker.Tag = currentResult; editor.AddMarker(marker); ext.markers.Enqueue(marker); } } builder.Add(new QuickTask(currentResult.Message, currentResult.Region.Start, currentResult.Level)); } return(true); }
private static async Task <int> FindSymbolsAsync(FindSymbolsCommandLineOptions options) { if (!options.TryGetProjectFilter(out ProjectFilter projectFilter)) { return(1); } if (!TryParseOptionValueAsEnumFlags(options.SymbolGroups, ParameterNames.SymbolGroups, out SymbolGroupFilter symbolGroups, SymbolFinderOptions.Default.SymbolGroups)) { return(1); } if (!TryParseOptionValueAsEnumFlags(options.Visibility, ParameterNames.Visibility, out VisibilityFilter visibility, SymbolFinderOptions.Default.Visibility)) { return(1); } if (!TryParseMetadataNames(options.WithAttributes, out ImmutableArray <MetadataName> withAttributes)) { return(1); } if (!TryParseMetadataNames(options.WithoutAttributes, out ImmutableArray <MetadataName> withoutAttributes)) { return(1); } if (!TryParseOptionValueAsEnumFlags(options.WithFlags, ParameterNames.WithFlags, out SymbolFlags withFlags, SymbolFlags.None)) { return(1); } if (!TryParseOptionValueAsEnumFlags(options.WithoutFlags, ParameterNames.WithoutFlags, out SymbolFlags withoutFlags, SymbolFlags.None)) { return(1); } ImmutableArray <SymbolFilterRule> .Builder rules = ImmutableArray.CreateBuilder <SymbolFilterRule>(); if (withAttributes.Any()) { rules.Add(new WithAttributeFilterRule(withAttributes)); } if (withoutAttributes.Any()) { rules.Add(new WithoutAttributeFilterRule(withoutAttributes)); } if (withFlags != SymbolFlags.None) { rules.AddRange(SymbolFilterRuleFactory.FromFlags(withFlags)); } if (withoutFlags != SymbolFlags.None) { rules.AddRange(SymbolFilterRuleFactory.FromFlags(withoutFlags, invert: true)); } var symbolFinderOptions = new SymbolFinderOptions( visibility: visibility, symbolGroups: symbolGroups, rules: rules, ignoreGeneratedCode: options.IgnoreGeneratedCode, unusedOnly: options.UnusedOnly); var command = new FindSymbolsCommand( options: options, symbolFinderOptions: symbolFinderOptions, projectFilter: projectFilter); CommandResult result = await command.ExecuteAsync(options.Path, options.MSBuildPath, options.Properties); return((result.Kind == CommandResultKind.Success) ? 0 : 1); }
/// <summary> /// Adds the <see cref="ImmutableArray{T}"/> of <see cref="IDiagnosticAnalyzer"/> defined in this assembly reference. /// </summary> internal void AddAnalyzers(ImmutableArray<IDiagnosticAnalyzer>.Builder builder, List<DiagnosticInfo> diagnosticsOpt, CommonMessageProvider messageProviderOpt) { // We handle loading of analyzer assemblies ourselves. This allows us to avoid locking the assembly // file on disk. Type[] types = null; Exception ex = null; try { Assembly analyzerAssembly = GetAssembly(); types = analyzerAssembly.GetTypes(); } catch (FileLoadException e) { ex = e; } catch (BadImageFormatException e) { ex = e; } catch (SecurityException e) { ex = e; } catch (ArgumentException e) { ex = e; } catch (PathTooLongException e) { ex = e; } catch (ReflectionTypeLoadException e) { ex = e; } if (ex != null) { var typeLoadEx = ex as ReflectionTypeLoadException; if (diagnosticsOpt != null && messageProviderOpt != null) { var message = typeLoadEx == null ? messageProviderOpt.WRN_UnableToLoadAnalyzer : messageProviderOpt.INF_UnableToLoadSomeTypesInAnalyzer; diagnosticsOpt.Add(new DiagnosticInfo(messageProviderOpt, message, fullPath, ex.Message)); } if (typeLoadEx != null) { types = typeLoadEx.Types.Where(t => t != null).ToArray(); } else { return; } } bool hasAnalyzers = false; foreach (var type in types) { try { if (type.GetTypeInfo().ImplementedInterfaces.Contains(typeof(IDiagnosticAnalyzer)) && type.IsDefined(typeof(DiagnosticAnalyzerAttribute))) { hasAnalyzers = true; builder.Add((IDiagnosticAnalyzer)Activator.CreateInstance(type)); } } catch (Exception e) { if (diagnosticsOpt != null && messageProviderOpt != null) { diagnosticsOpt.Add(new DiagnosticInfo(messageProviderOpt, messageProviderOpt.WRN_AnalyzerCannotBeCreated, type.FullName, fullPath, e.Message)); } } } if (!hasAnalyzers && ex == null && diagnosticsOpt != null && messageProviderOpt != null) { // If there are no analyzers in this assembly, let the user know. diagnosticsOpt.Add(new DiagnosticInfo(messageProviderOpt, messageProviderOpt.WRN_NoAnalyzerInAssembly, fullPath)); } }
private void ReadSectionDetails(ArchiveSectionMetadataBuilder[] sections) { #region Counts bool hasStreamCounts = false; ArchiveMetadataToken token; for (;;) { token = ReadToken(); if (token == ArchiveMetadataToken.End || token == ArchiveMetadataToken.CRC || token == ArchiveMetadataToken.Size) { break; } if (token == ArchiveMetadataToken.NumUnpackStream) { hasStreamCounts = true; foreach (var section in sections) { section.SubStreamCount = ReadNumberAsInt32(); } } else { SkipDataBlock(); } } if (!hasStreamCounts) { foreach (var section in sections) { section.SubStreamCount = 1; } } #endregion #region Sizes foreach (var section in sections) { // v3.13 was broken and wrote empty sections // v4.07 added compat code to skip empty sections if (section.SubStreamCount.Value == 0) { continue; } var remaining = section.OutputLength; var subsections = new DecodedStreamMetadata[section.SubStreamCount.Value]; for (int i = 0; i < subsections.Length - 1; i++) { if (token == ArchiveMetadataToken.Size) { var size = ReadNumberAsInt64(); if (size == 0 || size >= remaining) { throw new InvalidDataException(); } subsections[i] = new DecodedStreamMetadata(size, null); remaining -= size; } } if (remaining == 0) { throw new InvalidDataException(); } subsections[subsections.Length - 1] = new DecodedStreamMetadata(remaining, null); section.Subsections = subsections; } if (token == ArchiveMetadataToken.Size) { token = ReadToken(); } #endregion #region Checksums int requiredChecksumCount = 0; int totalChecksumCount = 0; ImmutableArray <Checksum?> .Builder checksums = null; foreach (var section in sections) { // If there is only one stream and we have a section checksum 7z doesn't store the checksum again. if (!(section.SubStreamCount == 1 && section.OutputChecksum.HasValue)) { requiredChecksumCount += section.SubStreamCount.Value; } totalChecksumCount += section.SubStreamCount.Value; } for (;;) { if (token == ArchiveMetadataToken.End) { if (checksums == null) { checksums = ImmutableArray.CreateBuilder <Checksum?>(totalChecksumCount); for (int i = 0; i < totalChecksumCount; i++) { checksums.Add(null); } } break; } else if (token == ArchiveMetadataToken.CRC) { checksums = ImmutableArray.CreateBuilder <Checksum?>(totalChecksumCount); var vector = ReadOptionalBitVector(requiredChecksumCount); int requiredChecksumIndex = 0; foreach (var section in sections) { if (section.SubStreamCount == 1 && section.OutputChecksum.HasValue) { checksums.Add(section.OutputChecksum.Value); } else { for (int i = 0; i < section.SubStreamCount; i++) { if (vector[requiredChecksumIndex++]) { checksums.Add(new Checksum(ReadInt32())); } else { checksums.Add(null); } } } } System.Diagnostics.Debug.Assert(requiredChecksumIndex == requiredChecksumCount); System.Diagnostics.Debug.Assert(checksums.Count == totalChecksumCount); } else { SkipDataBlock(); } token = ReadToken(); } #endregion }
private void AddAnalyzerExpressionCOmplexity(ImmutableArray<DiagnosticAnalyzer>.Builder builder) { var analyzer = new ExpressionComplexity(); if (!AnalyzerIds.Contains(analyzer.SupportedDiagnostics.Single().Id)) { return; } analyzer.Maximum = int.Parse( Parameters[analyzer.SupportedDiagnostics.Single().Id].Single()["max"], NumberStyles.None, CultureInfo.InvariantCulture); builder.Add(analyzer); }
private static void CreateReferences( ReferencedSymbol referencedSymbol, ImmutableArray<SourceReferenceItem>.Builder references, DefinitionItem definitionItem, HashSet<DocumentLocation> uniqueLocations) { foreach (var referenceLocation in referencedSymbol.Locations) { var location = referenceLocation.Location; Debug.Assert(location.IsInSource); var document = referenceLocation.Document; var sourceSpan = location.SourceSpan; var documentLocation = new DocumentLocation(document, sourceSpan); if (!documentLocation.CanNavigateTo()) { continue; } if (uniqueLocations.Add(documentLocation)) { references.Add(new SourceReferenceItem(definitionItem, documentLocation)); } } }
/// <summary> /// Adds the <see cref="ImmutableArray{IDiagnosticAnalyzer}"/> defined in this assembly reference /// </summary> internal void AddAnalyzers(ImmutableArray<IDiagnosticAnalyzer>.Builder builder, List<DiagnosticInfo> diagnosticsOpt, CommonMessageProvider messageProviderOpt) { // Using Assembly.LoadFrom to load into the Load-From context. This ensures that: // 1 . The analyzer and it's dependencies don't have to be in the probing path of this process // 2 . When multiple assemblies with the same identity are loaded (even from different paths), we return // the same assembly and avoid bloat. This does mean that strong identity for analyzers is important. Type[] types = null; Exception ex = null; try { Assembly analyzerAssembly = Assembly.LoadFrom(fullPath); types = analyzerAssembly.GetTypes(); } catch (FileLoadException e) { ex = e; } catch (BadImageFormatException e) { ex = e; } catch (SecurityException e) { ex = e; } catch (ArgumentException e) { ex = e; } catch (PathTooLongException e) { ex = e; } if (ex != null) { if (diagnosticsOpt != null && messageProviderOpt != null) { diagnosticsOpt.Add(new DiagnosticInfo(messageProviderOpt, messageProviderOpt.WRN_UnableToLoadAnalyzer, fullPath, ex.Message)); } return; } bool hasAnalyzers = false; foreach (var type in types) { if (type.GetTypeInfo().ImplementedInterfaces.Contains(typeof(IDiagnosticAnalyzer)) && type.IsDefined(typeof(DiagnosticAnalyzerAttribute))) { hasAnalyzers = true; try { builder.Add((IDiagnosticAnalyzer)Activator.CreateInstance(type)); } catch (Exception e) { if (diagnosticsOpt != null && messageProviderOpt != null) { diagnosticsOpt.Add(new DiagnosticInfo(messageProviderOpt, messageProviderOpt.WRN_AnalyzerCannotBeCreated, type, fullPath, e.Message)); } } } } if (!hasAnalyzers && diagnosticsOpt != null && messageProviderOpt != null) { // If there are no analyzers in this assembly, let the user know. diagnosticsOpt.Add(new DiagnosticInfo(messageProviderOpt, messageProviderOpt.WRN_NoAnalyzerInAssembly, fullPath)); } }
public static void CollectCommentRegions( SyntaxTriviaList triviaList, ImmutableArray<BlockSpan>.Builder spans) { if (triviaList.Count > 0) { SyntaxTrivia? startComment = null; SyntaxTrivia? endComment = null; Action completeSingleLineCommentGroup = () => { if (startComment != null) { var singleLineCommentGroupRegion = CreateCommentRegion(startComment.Value, endComment.Value); spans.Add(singleLineCommentGroupRegion); startComment = null; endComment = null; } }; // Iterate through trivia and collect the following: // 1. Groups of contiguous single-line comments that are only separated by whitespace // 2. Multi-line comments foreach (var trivia in triviaList) { if (trivia.IsSingleLineComment()) { startComment = startComment ?? trivia; endComment = trivia; } else if (trivia.IsMultiLineComment()) { completeSingleLineCommentGroup(); var multilineCommentRegion = CreateCommentRegion(trivia, trivia); spans.Add(multilineCommentRegion); } else if (!trivia.MatchesKind(SyntaxKind.WhitespaceTrivia, SyntaxKind.EndOfLineTrivia, SyntaxKind.EndOfFileToken)) { completeSingleLineCommentGroup(); } } completeSingleLineCommentGroup(); } }
private static void SplitRawLineIntoFormattedLines(string line, ImmutableArray<string>.Builder lines) { var indent = new StringBuilder().Append(' ', s_indentSize * 2).ToString(); var words = line.Split(' '); bool firstInLine = true; var sb = new StringBuilder(); sb.Append(indent); foreach (var word in words) { // We must always append at least one word to ensure progress. if (firstInLine) { firstInLine = false; } else { sb.Append(' '); } sb.Append(word); if (sb.Length >= s_wrapLength) { lines.Add(sb.ToString()); sb.Clear(); sb.Append(indent); firstInLine = true; } } if (sb.ToString().Trim() != string.Empty) { lines.Add(sb.ToString()); } }
private static void AddComponentsFlat(ImmutableArray<Type>.Builder result, Type t) { if (HarshTuple.IsTupleType(t)) { foreach (var ct in HarshTuple.GetComponentTypes(t)) { AddComponentsFlat(result, ct); } } else if (HarshGrouping.IsGroupingType(t)) { AddComponentsFlat(result, t.GenericTypeArguments[0]); AddComponentsFlat(result, t.GenericTypeArguments[1]); } else { result.Add(t); } }
private static void LzmaEnc_WriteProperties(Master.LZMA.CLzmaEncProps settings, ImmutableArray<byte>.Builder props) { settings.LzmaEncProps_Normalize(); uint dictSize = settings.mDictSize; props.Add((byte)((settings.mPB * 5 + settings.mLP) * 9 + settings.mLC)); for (int i = 11; i <= 30; i++) { if (dictSize <= (2u << i)) { dictSize = (2u << i); break; } if (dictSize <= (3u << i)) { dictSize = (3u << i); break; } } for (int i = 0; i < 4; i++) props.Add((byte)(dictSize >> (8 * i))); }
/// <summary> /// Update the destination database using data from source database using Id column as identification. /// </summary> /// <param name="destination">The destination database.</param> /// <param name="source">The source database.</param> /// <param name="records">The updated records from destination database.</param> /// <returns>True if destination database was updated.</returns> public static bool Update(XDatabase destination, XDatabase source, out ImmutableArray<XRecord>.Builder records) { bool isDirty = false; records = null; if (source == null || destination == null) { return isDirty; } // Check the number of source database columns. if (source.Columns.Length <= 1) { return isDirty; } // Check for presence of the Id column in the source database. if (source.Columns[0].Name != destination.IdColumnName) { return isDirty; } // Check for matching columns length. if (source.Columns.Length - 1 != destination.Columns.Length) { return isDirty; } // Check for matching column names. for (int i = 1; i < source.Columns.Length; i++) { if (source.Columns[i].Name != destination.Columns[i - 1].Name) { return isDirty; } } // Create updated records builder. records = destination.Records.ToBuilder(); // Update or remove existing records. for (int i = 0; i < destination.Records.Length; i++) { var record = destination.Records[i]; var result = source.Records.FirstOrDefault(r => r.Id == record.Id); if (result != null) { // Update existing record. for (int j = 1; j < result.Values.Length; j++) { var valuesBuilder = record.Values.ToBuilder(); valuesBuilder[j - 1] = result.Values[j]; record.Values = valuesBuilder.ToImmutable(); } isDirty = true; } else { // Remove existing record. records.Remove(record); isDirty = true; } } // Add new records. for (int i = 0; i < source.Records.Length; i++) { var record = source.Records[i]; var result = destination.Records.FirstOrDefault(r => r.Id == record.Id); if (result == null) { var r = source.Records[i]; // Use existing columns. r.Columns = destination.Columns; // Skip Id column. r.Values = r.Values.Skip(1).ToImmutableArray(); // Add new record. records.Add(r); isDirty = true; } } return isDirty; }
public RoslynCompilationWorkspace( InteractiveDependencyResolver dependencyResolver, TargetCompilationConfiguration compilationConfiguration, AgentType agentType, Type hostObjectType = null, bool includePeImagesInResolution = false) { if (dependencyResolver == null) { throw new ArgumentNullException(nameof(dependencyResolver)); } if (compilationConfiguration == null) { throw new ArgumentNullException(nameof(compilationConfiguration)); } workspace = new InteractiveWorkspace(); sourceReferenceResolver = new InteractiveSourceReferenceResolver(dependencyResolver); metadataReferenceResolver = new InteractiveMetadataReferenceResolver(dependencyResolver); monoScriptCompilationPatcher = new MonoScriptCompilationPatcher( assemblyNamePrefixBytes); DependencyResolver = dependencyResolver; this.hostObjectType = hostObjectType; EvaluationContextId = compilationConfiguration.EvaluationContextId; initialImports = compilationConfiguration.DefaultUsings.ToImmutableArray(); initialWarningSuppressions = compilationConfiguration.DefaultWarningSuppressions.ToImmutableArray(); initialDiagnosticOptions = initialWarningSuppressions.ToImmutableDictionary( warningId => warningId, warningId => ReportDiagnostic.Suppress); initialReferences = dependencyResolver.ResolveDefaultReferences(); var byNameImplicitReferences = new Tuple <string, Func <bool> > [] { Tuple.Create <string, Func <bool> > ("Microsoft.CSharp", () => true), // Add an implicit by name reference to System.ValueTuple if and only if the // agent is Console or WPF, and the current runtime does not have SVT in corlib. // This check makes sense because the Console and WPF agents run on the same // runtime as the current client. The other agents are on runtimes controlled // by us, and we can be sure that System.ValueTuple will be part of corlib on // those agents. A bug in .NET 4.7 means we can't just always implicitly add // the reference and have the runtime figure out what should be done. This bug // is fixed in .NET 4.7.1. Tuple.Create <string, Func <bool> > ("System.ValueTuple", () => { return((agentType == AgentType.Console || agentType == AgentType.WPF) && typeof(object).Assembly.GetType("System.ValueTuple") == null); }) }; foreach (var implicitReference in byNameImplicitReferences) { if (!implicitReference.Item2()) { continue; } var assembly = DependencyResolver.ResolveWithoutReferences( new AssemblyName(implicitReference.Item1)); if (assembly != null) { initialReferences = initialReferences.Add( MetadataReference.CreateFromFile(assembly.Path)); } } this.includePeImagesInResolution = includePeImagesInResolution; CompletionService = workspace .Services .GetLanguageServices(LanguageNames.CSharp) .GetService <CompletionService> (); }
private void BuildArrays(ImmutableArray<Node>.Builder nodes, ImmutableArray<Edge>.Builder edges) { var currentEdgeIndex = 0; for (var i = 0; i < _builderNodes.Length; i++) { var builderNode = _builderNodes[i]; var edgeCount = builderNode.EdgeCount; nodes.Add(new Node(builderNode.CharacterSpan, edgeCount, currentEdgeIndex)); if (edgeCount > 0) { // First, copy any edges that are in the compact array. var start = i * CompactEdgeAllocationSize; var end = start + Math.Min(edgeCount, CompactEdgeAllocationSize); for (var j = start; j < end; j++) { edges.Add(_compactEdges[j]); } // Then, if we've spilled over any edges, copy them as well. var spilledEdges = builderNode.SpilloverEdges; if (spilledEdges != null) { Debug.Assert(spilledEdges.Count == (edgeCount - CompactEdgeAllocationSize)); foreach (var kvp in spilledEdges) { edges.Add(new Edge(kvp.Key, kvp.Value)); } } } currentEdgeIndex += edgeCount; } Debug.Assert(currentEdgeIndex == edges.Capacity); Debug.Assert(currentEdgeIndex == edges.Count); }
internal LabelHandle AddLabel() { _labels.Add(-1); return(new LabelHandle(_labels.Count)); }
private static void CreateReferences( ReferencedSymbol referencedSymbol, ImmutableArray<SourceReferenceItem>.Builder references, DefinitionItem definitionItem, HashSet<DocumentSpan> uniqueSpans) { foreach (var referenceLocation in referencedSymbol.Locations) { var sourceReferenceItem = referenceLocation.TryCreateSourceReferenceItem(definitionItem); if (sourceReferenceItem == null) { continue; } if (uniqueSpans.Add(sourceReferenceItem.SourceSpan)) { references.Add(sourceReferenceItem); } } }
private void AddAnalyzerMagicNumber(ImmutableArray<DiagnosticAnalyzer>.Builder builder) { var analyzer = new MagicNumber(); if (!AnalyzerIds.Contains(analyzer.SupportedDiagnostics.Single().Id)) { return; } analyzer.Exceptions = Parameters[analyzer.SupportedDiagnostics.Single().Id].Single()["exceptions"] .Split(new [] {','}, StringSplitOptions.RemoveEmptyEntries) .Select(e => e.Trim()) .ToImmutableHashSet(); builder.Add(analyzer); }
private void ProcessReferencedSymbol( Solution solution, ReferencedSymbol referencedSymbol, ImmutableArray<DefinitionItem>.Builder definitions, ImmutableArray<SourceReferenceItem>.Builder references, HashSet<DocumentSpan> uniqueSpans) { // See if this is a symbol we even want to present to the user. If not, // ignore it entirely (including all its reference locations). if (!referencedSymbol.ShouldShow()) { return; } var definitionItem = referencedSymbol.Definition.ToDefinitionItem(solution, uniqueSpans); definitions.Add(definitionItem); // Now, create the SourceReferenceItems for all the reference locations // for this definition. CreateReferences(referencedSymbol, references, definitionItem, uniqueSpans); // Finally, see if there are any third parties that want to add their // own result to our collection. var thirdPartyItem = GetThirdPartyDefinitionItem(solution, referencedSymbol.Definition); if (thirdPartyItem != null) { definitions.Add(thirdPartyItem); } }
private void AddAnalyzerFileLines(ImmutableArray<DiagnosticAnalyzer>.Builder builder) { var analyzer = new FileLines(); if (!AnalyzerIds.Contains(analyzer.SupportedDiagnostics.Single().Id)) { return; } analyzer.Maximum = int.Parse( Parameters[analyzer.SupportedDiagnostics.Single().Id].Single()["maximumFileLocThreshold"], NumberStyles.None, CultureInfo.InvariantCulture); builder.Add(analyzer); }
private void FillNodeList(NavInfoList navInfoList, bool isObjectBrowser, bool isCanonical, ImmutableArray<IVsNavInfoNode>.Builder builder) { var index = 0; // In some cases, Class View presentation NavInfo objects will have extra nodes (LLT_PACKAGE & LLT_HIERARCHY) up front. // When this NavInfo is consumed by Object Browser (for 'Browse to Definition'), we need to skip first two nodes if (isObjectBrowser && !isCanonical) { if (navInfoList.Count >= 2 && navInfoList[1].ListType == (uint)_LIB_LISTTYPE.LLT_HIERARCHY) { index = 2; } } while (index < navInfoList.Count) { if (!isCanonical || navInfoList[index].ListType != (uint)_LIB_LISTTYPE.LLT_HIERARCHY) { builder.Add(navInfoList[index]); } index++; } }
protected void Add(string name) { ValidateName(name); _builder.Add($"/{name}"); }
private void GetEffectiveIncludesCore(ImmutableArray<string>.Builder arrayBuilder) { arrayBuilder.Add(this.FilePath); foreach (var ruleSetInclude in _includes) { var ruleSet = ruleSetInclude.LoadRuleSet(this); // If we couldn't load the ruleset file, then there's nothing to do. if (ruleSet == null) { continue; } // If this file has already been included don't recurse into it. if (!arrayBuilder.Contains(ruleSet.FilePath, StringComparer.OrdinalIgnoreCase)) { ruleSet.GetEffectiveIncludesCore(arrayBuilder); } } }
private static void AddPunctuation(this ImmutableArray <SymbolDisplayPart> .Builder builder, string text) { builder.Add(SymbolDisplayPartFactory.Punctuation(text)); }
public async Task AddPermissionOverwriteAsync(IUser user, OverwritePermissions perms, RequestOptions options = null) { await ChannelHelper.AddPermissionOverwriteAsync(this, Discord, user, perms, options).ConfigureAwait(false); _overwrites = _overwrites.Add(new Overwrite(user.Id, PermissionTarget.User, new OverwritePermissions(perms.AllowValue, perms.DenyValue))); }
private MetadataLoadedInfo LoadMetadata() { HashSet <ModuleDesc> metadataModules = new HashSet <ModuleDesc>(); MetadataType typeWithMetadataMappings = (MetadataType)_metadataDescribingModule.GetTypeByCustomAttributeTypeName(MetadataMappingTypeName); MethodDesc fullMetadataMethod = typeWithMetadataMappings.GetMethod("Metadata", null); MethodDesc weakMetadataMethod = typeWithMetadataMappings.GetMethod("WeakMetadata", null); ILProvider ilProvider = new ILProvider(null); MetadataLoadedInfo result = new MetadataLoadedInfo(); if (fullMetadataMethod != null) { MethodIL fullMethodIL = ilProvider.GetMethodIL(fullMetadataMethod); ReadMetadataMethod(fullMethodIL, out result.StrongTypeMappings, out result.MethodMappings, out result.FieldMappings, ref metadataModules); } if (weakMetadataMethod != null) { MethodIL weakMethodIL = ilProvider.GetMethodIL(weakMetadataMethod); List <MetadataMapping <MethodDesc> > weakMethodMappings = new List <MetadataMapping <MethodDesc> >(); List <MetadataMapping <FieldDesc> > weakFieldMappings = new List <MetadataMapping <FieldDesc> >(); ReadMetadataMethod(weakMethodIL, out result.AllTypeMappings, out weakMethodMappings, out weakFieldMappings, ref metadataModules); if ((weakMethodMappings.Count > 0) || (weakFieldMappings.Count > 0)) { // the format does not permit weak field/method mappings throw new BadImageFormatException(); } } #if DEBUG // No duplicates are permitted in metadata mappings HashSet <TypeSystemEntity> mappingsDuplicateChecker = new HashSet <TypeSystemEntity>(); foreach (MetadataMapping <MetadataType> mapping in result.AllTypeMappings) { if (!mappingsDuplicateChecker.Add(mapping.Entity)) { throw new BadImageFormatException(); } } foreach (MetadataMapping <MetadataType> mapping in result.StrongTypeMappings) { if (!mappingsDuplicateChecker.Add(mapping.Entity)) { throw new BadImageFormatException(); } } foreach (MetadataMapping <FieldDesc> mapping in result.FieldMappings) { if (!mappingsDuplicateChecker.Add(mapping.Entity)) { throw new BadImageFormatException(); } } foreach (MetadataMapping <MethodDesc> mapping in result.MethodMappings) { if (!mappingsDuplicateChecker.Add(mapping.Entity)) { throw new BadImageFormatException(); } } #endif // All type mappings is the combination of strong and weak type mappings. result.AllTypeMappings.AddRange(result.StrongTypeMappings); result.MetadataModules = ImmutableArray.CreateRange(metadataModules); ImmutableArray <ModuleDesc> .Builder externalMetadataModulesBuilder = ImmutableArray.CreateBuilder <ModuleDesc>(); ImmutableArray <ModuleDesc> .Builder localMetadataModulesBuilder = ImmutableArray.CreateBuilder <ModuleDesc>(); foreach (ModuleDesc module in result.MetadataModules) { if (!_compilationModules.Contains(module)) { externalMetadataModulesBuilder.Add(module); } else { localMetadataModulesBuilder.Add(module); } } result.ExternalMetadataModules = externalMetadataModulesBuilder.ToImmutable(); result.LocalMetadataModules = localMetadataModulesBuilder.ToImmutable(); return(result); }
public Node AddChild(Node child) => new Node(Name, Children.Add(child), ModulePath, FullModuleName);
public SubscribedList(IObservable <T> source) { _subscription = source.Subscribe(x => { _list = _list.Add(x); }); }
public static Either <ParseException, Pair <List <IToken>, BodyNode> > Parse(List <IToken> tokens, SymT symT, IScopedTable <IEntityType, string> parentTypeTable) { Console.WriteLine("BodyNode"); ImmutableArray <IAstNode> elements = ImmutableArray <IAstNode> .Empty; var typeTable = new Dictionary <string, IEntityType>(); var result = new BodyNode(ImmutableArray <IAstNode> .Empty, typeTable, parentTypeTable); while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } while (true) { var maybeSimpleDeclaration1 = VariableDeclarationNode.Parse(tokens, symT, result); if (maybeSimpleDeclaration1.IsRight) { tokens = maybeSimpleDeclaration1.RightToList()[0].First; var varDecl = maybeSimpleDeclaration1.RightToList()[0].Second; elements = elements.Add(varDecl); typeTable.TryAdd(varDecl.Identifier.Lexeme, varDecl.ToVariableType()); while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } continue; } var maybeSimpleDeclaration2 = TypeDeclarationNode.Parse(tokens, symT, result); if (maybeSimpleDeclaration2.IsRight) { tokens = maybeSimpleDeclaration2.RightToList()[0].First; var typeDecl = maybeSimpleDeclaration2.RightToList()[0].Second; elements = elements.Add(typeDecl); typeTable.TryAdd(typeDecl.Identifier.Lexeme, typeDecl.ToTypeAliasType()); while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } continue; } var maybeStatement = StatementNode.Parse(tokens, symT, result); if (maybeStatement.IsRight) { tokens = maybeStatement.RightToList()[0].First; elements = elements.Add(maybeStatement.RightToList()[0].Second); while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } continue; } var maybeExpression = StatementNode.Parse(tokens, symT, result); if (maybeExpression.IsRight) { tokens = maybeExpression.RightToList()[0].First; elements = elements.Add(maybeExpression.RightToList()[0].Second); while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } continue; } break; } if (tokens.Count < 1) { return(NotABodyException); } if (!(tokens[0] is ReturnKeywordToken)) { return(NotABodyException); } tokens = tokens.Skip(1).ToList(); var maybeExpression1 = ExpressionNode.Parse(tokens, result); if (maybeExpression1.IsRight) { while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } tokens = maybeExpression1.RightToList()[0].First; result.Elements = elements; result.ReturnExpressionNode = maybeExpression1.RightToList()[0].Second; var res = new Pair <List <IToken>, BodyNode>(tokens, result); return(res); } result.Elements = elements; return(new Pair <List <IToken>, BodyNode>(tokens, result)); }
public Dependency(IDependencyModel dependencyModel, ITargetFramework targetFramework, string containingProjectPath) { Requires.NotNull(dependencyModel, nameof(dependencyModel)); Requires.NotNullOrEmpty(dependencyModel.ProviderType, nameof(dependencyModel.ProviderType)); Requires.NotNullOrEmpty(dependencyModel.Id, nameof(dependencyModel.Id)); Requires.NotNull(targetFramework, nameof(targetFramework)); Requires.NotNullOrEmpty(containingProjectPath, nameof(containingProjectPath)); TargetFramework = targetFramework; _modelId = dependencyModel.Id; _containingProjectPath = containingProjectPath; ProviderType = dependencyModel.ProviderType; Name = dependencyModel.Name ?? string.Empty; Caption = dependencyModel.Caption ?? string.Empty; OriginalItemSpec = dependencyModel.OriginalItemSpec ?? string.Empty; Path = dependencyModel.Path ?? string.Empty; SchemaName = dependencyModel.SchemaName ?? Folder.SchemaName; _schemaItemType = dependencyModel.SchemaItemType ?? Folder.PrimaryDataSourceItemType; Resolved = dependencyModel.Resolved; TopLevel = dependencyModel.TopLevel; Implicit = dependencyModel.Implicit; Visible = dependencyModel.Visible; Priority = dependencyModel.Priority; Flags = dependencyModel.Flags; // Just in case custom providers don't do it, add corresponding flags for Resolved state. // This is needed for tree update logic to track if tree node changing state from unresolved // to resolved or vice-versa (it helps to decide if we need to remove it or update in-place // in the tree to avoid flicks). if (Resolved) { if (!Flags.Contains(DependencyTreeFlags.ResolvedFlags)) { Flags += DependencyTreeFlags.ResolvedFlags; } } else { if (!Flags.Contains(DependencyTreeFlags.UnresolvedFlags)) { Flags += DependencyTreeFlags.UnresolvedFlags; } } // If this is one of our implementations of IDependencyModel then we can just reuse the icon // set rather than creating a new one. if (dependencyModel is DependencyModel model) { IconSet = model.IconSet; } else { IconSet = DependencyIconSetCache.Instance.GetOrAddIconSet(dependencyModel.Icon, dependencyModel.ExpandedIcon, dependencyModel.UnresolvedIcon, dependencyModel.UnresolvedExpandedIcon); } Properties = dependencyModel.Properties ?? ImmutableStringDictionary <string> .EmptyOrdinal .Add(Folder.IdentityProperty, Caption) .Add(Folder.FullPathProperty, Path); if (dependencyModel.DependencyIDs == null || dependencyModel.DependencyIDs.Count == 0) { DependencyIDs = ImmutableArray <string> .Empty; } else { int count = dependencyModel.DependencyIDs.Count; ImmutableArray <string> .Builder ids = ImmutableArray.CreateBuilder <string>(count); for (int i = 0; i < count; i++) { ids.Add(GetID(TargetFramework, ProviderType, dependencyModel.DependencyIDs[i])); } DependencyIDs = ids.MoveToImmutable(); } }
private static Command CreateCommand(Type type, VerbAttribute verbAttribute) { ImmutableArray <CommandArgument> .Builder arguments = ImmutableArray.CreateBuilder <CommandArgument>(); ImmutableArray <CommandOption> .Builder options = ImmutableArray.CreateBuilder <CommandOption>(); Dictionary <string, string> providerMap = type .GetCustomAttributes <OptionValueProviderAttribute>() .ToDictionary(f => f.PropertyName, f => f.ProviderName); foreach (PropertyInfo propertyInfo in type.GetProperties(BindingFlags.Instance | BindingFlags.Public)) { OptionAttribute optionAttribute = null; foreach (Attribute attribute in propertyInfo.GetCustomAttributes()) { if (attribute is HiddenAttribute) { optionAttribute = null; break; } else if (attribute is ValueAttribute valueAttribute) { var argument = new CommandArgument( index: valueAttribute.Index, name: valueAttribute.MetaName, description: valueAttribute.HelpText, isRequired: valueAttribute.Required); arguments.Add(argument); break; } else if (optionAttribute == null) { optionAttribute = attribute as OptionAttribute; if (optionAttribute != null) { continue; } } } if (optionAttribute != null) { Debug.Assert( propertyInfo.PropertyType != typeof(bool) || string.IsNullOrEmpty(optionAttribute.MetaValue), $"{type.Name}.{propertyInfo.Name}"); var option = new CommandOption( name: optionAttribute.LongName, shortName: optionAttribute.ShortName, metaValue: optionAttribute.MetaValue, description: optionAttribute.HelpText, additionalDescription: propertyInfo.GetCustomAttribute <AdditionalDescriptionAttribute>()?.Text, isRequired: optionAttribute.Required, valueProviderName: (providerMap.TryGetValue(propertyInfo.Name, out string valueProviderName)) ? valueProviderName : null); options.Add(option); } } CommandGroupAttribute commandGroupAttribute = type.GetCustomAttribute <CommandGroupAttribute>() !; return(new Command( verbAttribute.Name, verbAttribute.HelpText, (commandGroupAttribute != null) ? new CommandGroup(commandGroupAttribute.Name, commandGroupAttribute.Ordinal) : CommandGroup.Default, arguments.OrderBy(f => f.Index), options.OrderBy(f => f, CommandOptionComparer.Name))); }
internal static ImmutableArray <T> Concat <T>(this ImmutableArray <T> first, T second) { return(first.Add(second)); }
public void Add(T subscriber) { lock (_subLock) _subscriptions = _subscriptions.Add(subscriber); }
private ImmutableArray <ArchiveFileSection> ReadRawStreamList() { var rawStreamBaseOffset = ReadNumberAsInt64() + ArchiveMetadataFormat.kHeaderLength; if (rawStreamBaseOffset < 0) { throw new InvalidDataException(); } var rawStreamCount = ReadNumberAsInt32(); SkipToToken(ArchiveMetadataToken.Size); var rawStreamSizes = new long[rawStreamCount]; for (int i = 0; i < rawStreamCount; i++) { rawStreamSizes[i] = ReadNumberAsInt64(); } ImmutableArray <ArchiveFileSection> .Builder rawStreamListBuilder = null; for (;;) { var token = ReadToken(); if (token == ArchiveMetadataToken.CRC) { var vector = ReadOptionalBitVector(rawStreamCount); var rawStreamOffset = rawStreamBaseOffset; rawStreamListBuilder = ImmutableArray.CreateBuilder <ArchiveFileSection>(rawStreamCount); for (int i = 0; i < rawStreamCount; i++) { var length = rawStreamSizes[i]; var checksum = default(Checksum?); if (vector[i]) { checksum = new Checksum(ReadInt32()); } rawStreamListBuilder.Add(new ArchiveFileSection(rawStreamOffset, length, checksum)); rawStreamOffset += length; } } else if (token == ArchiveMetadataToken.End) { if (rawStreamListBuilder == null) { var rawStreamOffset = rawStreamBaseOffset; rawStreamListBuilder = ImmutableArray.CreateBuilder <ArchiveFileSection>(rawStreamCount); for (int i = 0; i < rawStreamCount; i++) { var length = rawStreamSizes[i]; rawStreamListBuilder.Add(new ArchiveFileSection(rawStreamOffset, length, null)); rawStreamOffset += length; } } return(rawStreamListBuilder.MoveToImmutable()); } else { SkipDataBlock(); } } }
public void Add(T item) { _builder.Add(item); }
private void AddAnalyzerCommentRegularExpression(ImmutableArray<DiagnosticAnalyzer>.Builder builder) { if (!AnalyzerIds.Contains(CommentRegularExpression.DiagnosticId)) { return; } var rules = ImmutableArray.CreateBuilder<CommentRegularExpressionRule>(); foreach (var parameters in Parameters[CommentRegularExpression.DiagnosticId]) { rules.Add( new CommentRegularExpressionRule { // TODO: Add rule description Descriptor = CommentRegularExpression.CreateDiagnosticDescriptor(parameters["RuleKey"], parameters["message"]), RegularExpression = parameters["regularExpression"] }); } var analyzer = new CommentRegularExpression {RuleInstances = rules.ToImmutable()}; builder.Add(analyzer); }
private static void ParseMethodOrPropertySignature(ImmutableArray<byte>.Builder builder, Stream stream) { int paramCount = stream.ReadByte(); builder.Add((byte)paramCount); // Return type ParseType(builder, stream); // Parameters for (int i = 0; i < paramCount; i++) { ParseType(builder, stream, allowByRef: true); } }
private void AddAnalyzerClassName(ImmutableArray<DiagnosticAnalyzer>.Builder builder) { var analyzer = new ClassName(); if (!AnalyzerIds.Contains(analyzer.SupportedDiagnostics.Single().Id)) { return; } analyzer.Convention = Parameters[analyzer.SupportedDiagnostics.Single().Id].Single()["format"]; builder.Add(analyzer); }
private static void ParseGenericTypeInstance(ImmutableArray<byte>.Builder builder, Stream stream) { ParseType(builder, stream); // Generic type parameters int argumentCount = stream.ReadByte(); builder.Add((byte)argumentCount); for (int i = 0; i < argumentCount; i++) { ParseType(builder, stream); } }
private void AddAnalyzerTooManyLabelsInSwitch(ImmutableArray<DiagnosticAnalyzer>.Builder builder) { var analyzer = new TooManyLabelsInSwitch(); if (!AnalyzerIds.Contains(analyzer.SupportedDiagnostics.Single().Id)) { return; } analyzer.Maximum = int.Parse( Parameters[analyzer.SupportedDiagnostics.Single().Id].Single()["maximum"], NumberStyles.None, CultureInfo.InvariantCulture); builder.Add(analyzer); }
public void CollectBlockSpans(SyntaxTree syntaxTree, SyntaxTrivia trivia, ImmutableArray<BlockSpan>.Builder spans, CancellationToken cancellationToken) { // We'll always be leading trivia of some token. var startPos = trivia.FullSpan.Start; var endPos = trivia.FullSpan.End; // Look through our parent token's trivia, to: // 1. See if we're the first disabled trivia attached to the token. // 2. To extend the span to the end of the last disabled trivia. // // The issue is that if there are other pre-processor directives (like #regions or // #lines) mixed in the disabled code, they will be interleaved. Keep walking past // them to the next thing that will actually end a disabled block. When we encounter // one, we must also consider which opening block they end. In case of nested pre-processor // directives, the inner most end block should match the inner most open block and so on. var parentTriviaList = trivia.Token.LeadingTrivia; var indexInParent = parentTriviaList.IndexOf(trivia); // Note: in some error cases (for example when all future tokens end up being skipped) // the parser may end up attaching pre-processor directives as trailing trivia to a // preceding token. if (indexInParent < 0) { parentTriviaList = trivia.Token.TrailingTrivia; indexInParent = parentTriviaList.IndexOf(trivia); } if (indexInParent <= 0 || (!parentTriviaList[indexInParent - 1].IsKind(SyntaxKind.IfDirectiveTrivia) && !parentTriviaList[indexInParent - 1].IsKind(SyntaxKind.ElifDirectiveTrivia) && !parentTriviaList[indexInParent - 1].IsKind(SyntaxKind.ElseDirectiveTrivia))) { return; } var nestedIfDirectiveTrivia = 0; for (int i = indexInParent; i < parentTriviaList.Count; i++) { if (parentTriviaList[i].IsKind(SyntaxKind.IfDirectiveTrivia)) { nestedIfDirectiveTrivia++; } if (parentTriviaList[i].IsKind(SyntaxKind.EndIfDirectiveTrivia) || parentTriviaList[i].IsKind(SyntaxKind.ElifDirectiveTrivia) || parentTriviaList[i].IsKind(SyntaxKind.ElseDirectiveTrivia)) { if (nestedIfDirectiveTrivia > 0) { nestedIfDirectiveTrivia--; } else { endPos = parentTriviaList[i - 1].FullSpan.End; break; } } } // Now, exclude the last newline if there is one. var text = syntaxTree.GetText(cancellationToken); if (endPos > 1 && text[endPos - 1] == '\n' && text[endPos - 2] == '\r') { endPos -= 2; } else if (endPos > 0 && SyntaxFacts.IsNewLine(text[endPos - 1])) { endPos--; } var span = TextSpan.FromBounds(startPos, endPos); spans.Add(new BlockSpan( isCollapsible: true, textSpan: span, bannerText: CSharpStructureHelpers.Ellipsis, autoCollapse: true)); }
/// <summary> /// Produces the series of statements to build the current HLSL source. /// </summary> /// <param name="hlslSourceInfo">The input <see cref="HlslShaderSourceInfo"/> instance to use.</param> /// <returns>The series of statements to build the HLSL source to compile to execute the current shader.</returns> private static ImmutableArray <StatementSyntax> GenerateRenderMethodBody(HlslShaderSourceInfo hlslSourceInfo) { ImmutableArray <StatementSyntax> .Builder statements = ImmutableArray.CreateBuilder <StatementSyntax>(); StringBuilder textBuilder = new(); int capturedDelegates = 0; int prologueStatements = 0; int sizeHint = 64; void AppendLF() { textBuilder.Append('\n'); } void AppendLine(string text) { textBuilder.Append(text); } void AppendParsedStatement(string text) { FlushText(); statements.Add(ParseStatement(text)); } void FlushText() { if (textBuilder.Length > 0) { string text = textBuilder.ToString(); textBuilder.Append(text); sizeHint += textBuilder.Length; statements.Add( ExpressionStatement( InvocationExpression( MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, IdentifierName("builder"), IdentifierName("Append"))) .AddArgumentListArguments(Argument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(text)))))); textBuilder.Clear(); } } // Declare the hashsets to track imported members and types from delegates, if needed if (!hlslSourceInfo.Delegates.IsEmpty) { void DeclareMapping(int index, string name, IEnumerable <string> items) { // global::System.Collections.Generic.HashSet<string> <NAME> = new(); statements.Insert(index, LocalDeclarationStatement(VariableDeclaration( GenericName(Identifier("global::System.Collections.Generic.HashSet")) .AddTypeArgumentListArguments(PredefinedType(Token(SyntaxKind.StringKeyword)))) .AddVariables( VariableDeclarator(Identifier(name)) .WithInitializer(EqualsValueClause(ImplicitObjectCreationExpression()))))); prologueStatements++; // <NAME>.Add("<ITEM>"); foreach (var item in items) { statements.Add( ExpressionStatement( InvocationExpression( MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, IdentifierName(name), IdentifierName("Add"))) .AddArgumentListArguments(Argument( LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(item)))))); prologueStatements++; } } DeclareMapping(0, "__typeNames", hlslSourceInfo.DefinedTypes); DeclareMapping(1, "__constantNames", hlslSourceInfo.DefinedConstants); DeclareMapping(2, "__methodNames", hlslSourceInfo.MethodSignatures); // Go through all existing delegate fields, if any foreach (string fieldName in hlslSourceInfo.Delegates) { // global::ComputeSharp.__Internals.ShaderMethodSourceAttribute __<DELEGATE_NAME>Attribute = global::ComputeSharp.__Internals.ShaderMethodSourceAttribute.GetForDelegate(<DELEGATE_NAME>, "<DELEGATE_NAME>"); statements.Add( LocalDeclarationStatement(VariableDeclaration(IdentifierName($"global::ComputeSharp.__Internals.{nameof(ShaderMethodSourceAttribute)}")) .AddVariables( VariableDeclarator(Identifier($"__{fieldName}Attribute")) .WithInitializer( EqualsValueClause( InvocationExpression( MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, IdentifierName($"global::ComputeSharp.__Internals.{nameof(ShaderMethodSourceAttribute)}"), IdentifierName(nameof(ShaderMethodSourceAttribute.GetForDelegate)))) .AddArgumentListArguments( Argument(IdentifierName(fieldName)), Argument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(fieldName))))))))); capturedDelegates++; prologueStatements++; } } // Header and thread ids AppendLine(hlslSourceInfo.HeaderAndThreadsX); AppendParsedStatement("builder.Append(threadsX);"); AppendLine(hlslSourceInfo.ThreadsY); AppendParsedStatement("builder.Append(threadsY);"); AppendLine(hlslSourceInfo.ThreadsZ); AppendParsedStatement("builder.Append(threadsZ);"); // Define declarations AppendLine(hlslSourceInfo.Defines); // Defines from captured delegates foreach (string fieldName in hlslSourceInfo.Delegates) { AppendParsedStatement($"__{fieldName}Attribute.AppendConstants(ref builder, __constantNames);"); } // Static fields and declared types AppendLine(hlslSourceInfo.StaticFieldsAndDeclaredTypes); // Declared types from captured delegates foreach (string fieldName in hlslSourceInfo.Delegates) { AppendParsedStatement($"__{fieldName}Attribute.AppendTypes(ref builder, __typeNames);"); } // Captured variables AppendLine(hlslSourceInfo.CapturedFieldsAndResourcesAndForwardDeclarations); // Forward declarations from captured delegates foreach (string fieldName in hlslSourceInfo.Delegates) { AppendParsedStatement($"__{fieldName}Attribute.AppendForwardDeclarations(ref builder, __methodNames);"); } // Remove all forward declarations from methods that are embedded into the shader. // This is necessary to avoid duplicate definitions from methods from delegates. if (capturedDelegates > 0) { // <NAME>.Add("<ITEM>"); foreach (string forwardDeclaration in hlslSourceInfo.MethodSignatures) { FlushText(); statements.Add( ExpressionStatement( InvocationExpression( MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, IdentifierName("__methodNames"), IdentifierName("Remove"))) .AddArgumentListArguments(Argument( LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(forwardDeclaration)))))); } } // Captured methods AppendLine(hlslSourceInfo.CapturedMethods); // Captured methods from captured delegates foreach (string fieldName in hlslSourceInfo.Delegates) { AppendParsedStatement($"__{fieldName}Attribute.AppendMethods(ref builder, __methodNames);"); } // Captured delegate methods foreach (string fieldName in hlslSourceInfo.Delegates) { AppendLF(); AppendParsedStatement($"__{fieldName}Attribute.AppendMappedInvokeMethod(ref builder, \"{fieldName}\");"); AppendLF(); } // Entry point AppendLine(hlslSourceInfo.EntryPoint); FlushText(); // builder = global::ComputeSharp.__Internals.ArrayPoolStringBuilder.Create(<SIZE_HINT>); statements.Insert( prologueStatements, ExpressionStatement( AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, IdentifierName("builder"), InvocationExpression( MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, IdentifierName("global::ComputeSharp.__Internals.ArrayPoolStringBuilder"), IdentifierName("Create"))) .AddArgumentListArguments( Argument(LiteralExpression( SyntaxKind.NumericLiteralExpression, Literal(sizeHint))))))); return(statements.ToImmutable()); }
private static void AddIndentation(this ImmutableArray <SymbolDisplayPart> .Builder builder) { builder.Add(SymbolDisplayPartFactory.Indentation()); }
/// <summary> /// Gets a sequence of statements to load the input descriptions for a given shader. /// </summary> /// <param name="inputDescriptions">The array of <see cref="InputDescription"/> values for all available input descriptions.</param> /// <returns>The sequence of <see cref="StatementSyntax"/> instances to load shader dispatch data.</returns> private static ImmutableArray <StatementSyntax> GetInputDescriptionsLoadingStatements(ImmutableArray <InputDescription> inputDescriptions) { // If there are no input descriptions available, just load an empty buffer if (inputDescriptions.IsEmpty) { // loader.LoadInputDescriptions(default); return (ImmutableArray.Create <StatementSyntax>( ExpressionStatement( InvocationExpression( MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, IdentifierName("loader"), IdentifierName("LoadInputDescriptions"))) .AddArgumentListArguments(Argument( LiteralExpression( SyntaxKind.DefaultLiteralExpression, Token(SyntaxKind.DefaultKeyword))))))); } ImmutableArray <StatementSyntax> .Builder statements = ImmutableArray.CreateBuilder <StatementSyntax>(); // The size of the buffer with the input descriptions is the number of input descriptions, times the size of each // input description, which is a struct containing three int-sized fields (index, filter, and level of detail). int inputDescriptionSizeInBytes = inputDescriptions.Length * sizeof(int) * 3; // global::System.Span<byte> data = stackalloc byte[<INPUT_DESCRIPTIONS_SIZE>]; statements.Insert(0, LocalDeclarationStatement( VariableDeclaration( GenericName(Identifier("global::System.Span")) .AddTypeArgumentListArguments(PredefinedType(Token(SyntaxKind.ByteKeyword)))) .AddVariables( VariableDeclarator(Identifier("data")) .WithInitializer(EqualsValueClause( StackAllocArrayCreationExpression( ArrayType(PredefinedType(Token(SyntaxKind.ByteKeyword))) .AddRankSpecifiers( ArrayRankSpecifier(SingletonSeparatedList <ExpressionSyntax>( LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(inputDescriptionSizeInBytes))))))))))); // ref byte r0 = ref data[0]; statements.Insert(1, LocalDeclarationStatement( VariableDeclaration(RefType(PredefinedType(Token(SyntaxKind.ByteKeyword)))) .AddVariables( VariableDeclarator(Identifier("r0")) .WithInitializer(EqualsValueClause( RefExpression( ElementAccessExpression(IdentifierName("data")) .AddArgumentListArguments(Argument( LiteralExpression( SyntaxKind.NumericLiteralExpression, Literal(0)))))))))); int offset = 0; // Generate loading statements for each input description foreach (InputDescription inputDescription in inputDescriptions) { // Write the index of the current input description: // // global::System.Runtime.CompilerServices.Unsafe.As<byte, uint>(ref global::System.Runtime.CompilerServices.Unsafe.AddByteOffset(ref r0, (nint)<OFFSET>)) = <INDEX>; statements.Add(ExpressionStatement( AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, ParseExpression($"global::System.Runtime.CompilerServices.Unsafe.As<byte, uint>(ref global::System.Runtime.CompilerServices.Unsafe.AddByteOffset(ref r0, (nint){offset}))"), LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal((int)inputDescription.Index))))); // Write the filter of the current input description: // // global::System.Runtime.CompilerServices.Unsafe.As<byte, uint>(ref global::System.Runtime.CompilerServices.Unsafe.AddByteOffset(ref r0, (nint)<OFFSET> + 4)) = <FILTER>; statements.Add(ExpressionStatement( AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, ParseExpression($"global::System.Runtime.CompilerServices.Unsafe.As<byte, uint>(ref global::System.Runtime.CompilerServices.Unsafe.AddByteOffset(ref r0, (nint){offset + 4}))"), LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal((int)inputDescription.Filter))))); // Write the level of detail of the current input description: // // global::System.Runtime.CompilerServices.Unsafe.As<byte, uint>(ref global::System.Runtime.CompilerServices.Unsafe.AddByteOffset(ref r0, (nint)<OFFSET> + 8)) = <LEVEL_OF_DETAIL>; statements.Add(ExpressionStatement( AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, ParseExpression($"global::System.Runtime.CompilerServices.Unsafe.As<byte, uint>(ref global::System.Runtime.CompilerServices.Unsafe.AddByteOffset(ref r0, (nint){offset + 8}))"), LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal((int)inputDescription.LevelOfDetail))))); offset += sizeof(int) * 3; } // loader.LoadInputDescriptions(data); statements.Add( ExpressionStatement( InvocationExpression( MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, IdentifierName("loader"), IdentifierName("LoadInputDescriptions"))) .AddArgumentListArguments(Argument(IdentifierName("data"))))); return(statements.ToImmutable()); }
private static void AddLineBreak(this ImmutableArray <SymbolDisplayPart> .Builder builder) { builder.Add(SymbolDisplayPartFactory.LineBreak()); }
public static ImmutableArray <SymbolDisplayPart> GetDisplayParts( ISymbol symbol, SymbolDisplayFormat format, SymbolDisplayTypeDeclarationOptions typeDeclarationOptions = SymbolDisplayTypeDeclarationOptions.None, Func <INamedTypeSymbol, bool> isVisibleAttribute = null, bool formatBaseList = false, bool formatConstraints = false, bool formatParameters = false, bool splitAttributes = true, bool includeAttributeArguments = false, bool omitIEnumerable = false, bool useNameOnlyIfPossible = false) { ImmutableArray <SymbolDisplayPart> parts; if (symbol is INamedTypeSymbol typeSymbol) { parts = typeSymbol.ToDisplayParts(format, typeDeclarationOptions); } else { parts = symbol.ToDisplayParts(format); typeSymbol = null; } ImmutableArray <AttributeData> attributes = ImmutableArray <AttributeData> .Empty; bool hasAttributes = false; if (isVisibleAttribute != null) { attributes = symbol.GetAttributes(); hasAttributes = attributes.Any(f => isVisibleAttribute(f.AttributeClass)); } int baseListCount = 0; INamedTypeSymbol baseType = null; ImmutableArray <INamedTypeSymbol> interfaces = default; if (typeSymbol != null) { if (typeSymbol.TypeKind.Is(TypeKind.Class, TypeKind.Interface)) { baseType = typeSymbol.BaseType; if (baseType?.SpecialType == SpecialType.System_Object) { baseType = null; } } interfaces = typeSymbol.Interfaces; if (omitIEnumerable && interfaces.Any(f => f.OriginalDefinition.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T)) { interfaces = interfaces.RemoveAll(f => f.SpecialType == SpecialType.System_Collections_IEnumerable); } baseListCount = interfaces.Length; if (baseType != null) { baseListCount++; } } int constraintCount = 0; int whereIndex = -1; for (int i = 0; i < parts.Length; i++) { if (parts[i].IsKeyword("where")) { if (whereIndex == -1) { whereIndex = i; } constraintCount++; } } if (!hasAttributes && baseListCount == 0 && constraintCount == 0 && (!formatParameters || symbol.GetParameters().Length <= 1)) { return(parts); } INamespaceSymbol containingNamespace = (useNameOnlyIfPossible) ? symbol.ContainingNamespace : null; ImmutableArray <SymbolDisplayPart> .Builder builder = ImmutableArray.CreateBuilder <SymbolDisplayPart>(parts.Length); AddAttributes(builder, attributes, isVisibleAttribute, containingNamespace, splitAttributes: splitAttributes, includeAttributeArguments: includeAttributeArguments); if (baseListCount > 0) { if (whereIndex != -1) { builder.AddRange(parts, whereIndex); } else { builder.AddRange(parts); builder.AddSpace(); } builder.AddPunctuation(":"); builder.AddSpace(); if (baseType != null) { builder.AddDisplayParts(baseType, containingNamespace); if (interfaces.Any()) { builder.AddPunctuation(","); if (formatBaseList) { builder.AddLineBreak(); builder.AddIndentation(); } else { builder.AddSpace(); } } } interfaces = interfaces.Sort((x, y) => { INamespaceSymbol n1 = x.ContainingNamespace; INamespaceSymbol n2 = y.ContainingNamespace; if (!MetadataNameEqualityComparer <INamespaceSymbol> .Instance.Equals(n1, n2)) { return(string.CompareOrdinal( n1.ToDisplayString(SymbolDisplayFormats.TypeNameAndContainingTypesAndNamespaces), n2.ToDisplayString(SymbolDisplayFormats.TypeNameAndContainingTypesAndNamespaces))); } return(string.CompareOrdinal( ToDisplayString(x, containingNamespace), ToDisplayString(y, containingNamespace))); }); ImmutableArray <INamedTypeSymbol> .Enumerator en = interfaces.GetEnumerator(); if (en.MoveNext()) { while (true) { builder.AddDisplayParts(en.Current, containingNamespace); if (en.MoveNext()) { builder.AddPunctuation(","); if (formatBaseList) { builder.AddLineBreak(); builder.AddIndentation(); } else { builder.AddSpace(); } } else { break; } } } if (whereIndex != -1) { if (!formatConstraints || (baseListCount == 1 && constraintCount == 1)) { builder.AddSpace(); } } } else if (whereIndex != -1) { builder.AddRange(parts, whereIndex); } else { builder.AddRange(parts); } if (whereIndex != -1) { for (int i = whereIndex; i < parts.Length; i++) { if (parts[i].IsKeyword("where")) { if (formatConstraints && (baseListCount > 1 || constraintCount > 1)) { builder.AddLineBreak(); builder.AddIndentation(); } builder.Add(parts[i]); } else if (parts[i].IsTypeName() && parts[i].Symbol is INamedTypeSymbol namedTypeSymbol) { builder.AddDisplayParts(namedTypeSymbol, containingNamespace); } else { builder.Add(parts[i]); } } } if (formatParameters) { ImmutableArray <IParameterSymbol> parameters = symbol.GetParameters(); if (parameters.Length > 1) { FormatParameters(symbol, builder, DeclarationListOptions.DefaultValues.IndentChars); } } return(builder.ToImmutableArray()); }
private void AddAnalyzerCommentRegularExpression(ImmutableArray<DiagnosticAnalyzer>.Builder builder) { if (!AnalyzerIds.Contains(Rules.CSharp.CommentRegularExpression.TemplateDiagnosticId)) { return; } var rules = ImmutableArray.CreateBuilder<CommentRegularExpression.CommentRegularExpressionRule>(); foreach (var parameterValues in parameters .Where(p => p.RuleId == CommentRegularExpression.TemplateDiagnosticId) .Select(p => p.ParameterValues)) { rules.Add( new CommentRegularExpression.CommentRegularExpressionRule( parameterValues.Single(pv => pv.ParameterKey == "RuleKey").ParameterValue, parameterValues.Single(pv => pv.ParameterKey == "regularExpression").ParameterValue, parameterValues.Single(pv => pv.ParameterKey == "message").ParameterValue)); } var analyzer = new CommentRegularExpression {RuleInstances = rules.ToImmutable()}; builder.Add(analyzer); }
private static void ParseType(ImmutableArray<byte>.Builder builder, Stream stream, bool allowByRef = false) { while (true) { var typeCode = (SignatureTypeCode)stream.ReadByte(); builder.Add((byte)typeCode); switch (typeCode) { default: throw ExceptionUtilities.UnexpectedValue(typeCode); case SignatureTypeCode.TypeHandle: case SignatureTypeCode.GenericTypeParameter: case SignatureTypeCode.GenericMethodParameter: builder.Add((byte)stream.ReadByte()); return; case SignatureTypeCode.ByReference: if (!allowByRef) goto default; break; case SignatureTypeCode.SZArray: break; case SignatureTypeCode.Pointer: break; case SignatureTypeCode.GenericTypeInstance: ParseGenericTypeInstance(builder, stream); return; } allowByRef = false; } }
private static void AddAttributes( ImmutableArray <SymbolDisplayPart> .Builder builder, ImmutableArray <AttributeData> attributes, Func <INamedTypeSymbol, bool> predicate = null, INamespaceSymbol containingNamespace = null, bool splitAttributes = true, bool includeAttributeArguments = false, bool isAssemblyAttribute = false, bool addNewLine = true) { using (IEnumerator <AttributeData> en = attributes .Where(f => predicate(f.AttributeClass)) .OrderBy(f => ToDisplayString(f.AttributeClass, containingNamespace)).GetEnumerator()) { if (en.MoveNext()) { builder.AddPunctuation("["); if (isAssemblyAttribute) { builder.AddKeyword("assembly"); builder.AddPunctuation(":"); builder.AddSpace(); } while (true) { builder.AddDisplayParts(en.Current.AttributeClass, containingNamespace); if (includeAttributeArguments) { AddAttributeArguments(en.Current); } if (en.MoveNext()) { if (splitAttributes) { builder.AddPunctuation("]"); if (addNewLine) { builder.AddLineBreak(); } else { builder.AddSpace(); } builder.AddPunctuation("["); if (isAssemblyAttribute) { builder.AddKeyword("assembly"); builder.AddPunctuation(":"); builder.AddSpace(); } } else { builder.AddPunctuation(","); builder.AddSpace(); } } else { break; } } builder.AddPunctuation("]"); if (addNewLine) { builder.AddLineBreak(); } } } void AddAttributeArguments(AttributeData attributeData) { bool hasConstructorArgument = false; bool hasNamedArgument = false; AppendConstructorArguments(); AppendNamedArguments(); if (hasConstructorArgument || hasNamedArgument) { builder.AddPunctuation(")"); } void AppendConstructorArguments() { ImmutableArray <TypedConstant> .Enumerator en = attributeData.ConstructorArguments.GetEnumerator(); if (en.MoveNext()) { hasConstructorArgument = true; builder.AddPunctuation("("); while (true) { AddConstantValue(en.Current); if (en.MoveNext()) { builder.AddPunctuation(","); builder.AddSpace(); } else { break; } } } } void AppendNamedArguments() { ImmutableArray <KeyValuePair <string, TypedConstant> > .Enumerator en = attributeData.NamedArguments.GetEnumerator(); if (en.MoveNext()) { hasNamedArgument = true; if (hasConstructorArgument) { builder.AddPunctuation(","); builder.AddSpace(); } else { builder.AddPunctuation("("); } while (true) { builder.Add(new SymbolDisplayPart(SymbolDisplayPartKind.PropertyName, null, en.Current.Key)); builder.AddSpace(); builder.AddPunctuation("="); builder.AddSpace(); AddConstantValue(en.Current.Value); if (en.MoveNext()) { builder.AddPunctuation(","); builder.AddSpace(); } else { break; } } } } } void AddConstantValue(TypedConstant typedConstant) { switch (typedConstant.Kind) { case TypedConstantKind.Primitive: { builder.Add(new SymbolDisplayPart( GetSymbolDisplayPart(typedConstant.Type.SpecialType), null, SymbolDisplay.FormatPrimitive(typedConstant.Value, quoteStrings: true, useHexadecimalNumbers: false))); break; } case TypedConstantKind.Enum: { OneOrMany <EnumFieldInfo> oneOrMany = EnumUtility.GetConstituentFields(typedConstant.Value, (INamedTypeSymbol)typedConstant.Type); OneOrMany <EnumFieldInfo> .Enumerator en = oneOrMany.GetEnumerator(); if (en.MoveNext()) { while (true) { AddDisplayParts(builder, en.Current.Symbol, containingNamespace); if (en.MoveNext()) { builder.AddSpace(); builder.AddPunctuation("|"); builder.AddSpace(); } else { break; } } } else { builder.AddPunctuation("("); AddDisplayParts(builder, (INamedTypeSymbol)typedConstant.Type, containingNamespace); builder.AddPunctuation(")"); builder.Add(new SymbolDisplayPart(SymbolDisplayPartKind.NumericLiteral, null, typedConstant.Value.ToString())); } break; } case TypedConstantKind.Type: { builder.AddKeyword("typeof"); builder.AddPunctuation("("); AddDisplayParts(builder, (ISymbol)typedConstant.Value, containingNamespace); builder.AddPunctuation(")"); break; } case TypedConstantKind.Array: { var arrayType = (IArrayTypeSymbol)typedConstant.Type; builder.AddKeyword("new"); builder.AddSpace(); AddDisplayParts(builder, arrayType.ElementType, containingNamespace); builder.AddPunctuation("["); builder.AddPunctuation("]"); builder.AddSpace(); builder.AddPunctuation("{"); builder.AddSpace(); ImmutableArray <TypedConstant> .Enumerator en = typedConstant.Values.GetEnumerator(); if (en.MoveNext()) { while (true) { AddConstantValue(en.Current); if (en.MoveNext()) { builder.AddPunctuation(","); builder.AddSpace(); } else { break; } } } builder.AddSpace(); builder.AddPunctuation("}"); break; } default: { throw new InvalidOperationException(); } } SymbolDisplayPartKind GetSymbolDisplayPart(SpecialType specialType) { switch (specialType) { case SpecialType.System_Boolean: return(SymbolDisplayPartKind.Keyword); case SpecialType.System_SByte: case SpecialType.System_Byte: case SpecialType.System_Int16: case SpecialType.System_UInt16: case SpecialType.System_Int32: case SpecialType.System_UInt32: case SpecialType.System_Int64: case SpecialType.System_UInt64: case SpecialType.System_Single: case SpecialType.System_Double: return(SymbolDisplayPartKind.NumericLiteral); case SpecialType.System_Char: case SpecialType.System_String: return(SymbolDisplayPartKind.StringLiteral); default: throw new InvalidOperationException(); } } } }
private void AddInheritanceName( ImmutableArray<string>.Builder builder, TypeSyntax type, List<Dictionary<string, string>> aliasMaps) { var name = GetTypeName(type); if (name != null) { // First, add the name that the typename that the type directly says it inherits from. builder.Add(name); // Now, walk the alias chain and add any names this alias may eventually map to. var currentName = name; foreach (var aliasMap in aliasMaps) { string mappedName; if (aliasMap.TryGetValue(currentName, out mappedName)) { // Looks like this could be an alias. Also include the name the alias points to builder.Add(mappedName); // Keep on searching. An alias in an inner namespcae can refer to an // alias in an outer namespace. currentName = mappedName; } } } }
private static void AddSpace(this ImmutableArray <SymbolDisplayPart> .Builder builder) { builder.Add(SymbolDisplayPartFactory.Space()); }