private async Task<Document> FixAllAsync(
Document document, ImmutableArray<Diagnostic> diagnostics, CancellationToken cancellationToken)
{
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
// Create an editor to do all the transformations. This allows us to fix all
// the diagnostics in a clean manner. If we used the normal batch fix provider
// then it might fail to apply all the individual text changes as many of the
// changes produced by the diff might end up overlapping others.
var editor = new SyntaxEditor(root, document.Project.Solution.Workspace);
var options = document.Project.Solution.Workspace.Options;
// Attempt to use an out-var declaration if that's the style the user prefers.
// Note: if using 'var' would cause a problem, we will use the actual type
// of hte local. This is necessary in some cases (for example, when the
// type of the out-var-decl affects overload resolution or generic instantiation).
var useVarWhenDeclaringLocals = options.GetOption(CSharpCodeStyleOptions.UseVarWhenDeclaringLocals);
var useImplicitTypeForIntrinsicTypes = options.GetOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes).Value;
foreach (var diagnostic in diagnostics)
{
cancellationToken.ThrowIfCancellationRequested();
await AddEditsAsync(document, editor, diagnostic,
useVarWhenDeclaringLocals, useImplicitTypeForIntrinsicTypes,
cancellationToken).ConfigureAwait(false);
}
var newRoot = editor.GetChangedRoot();
return document.WithSyntaxRoot(newRoot);
}
private async Task VerifyFixInternalAsync(string language, ImmutableArray<DiagnosticAnalyzer> analyzers, CodeFixProvider codeFixProvider, string oldSource, string newSource, int? codeFixIndex,
bool allowNewCompilerDiagnostics, int maxNumberOfIterations, Func<ImmutableArray<DiagnosticAnalyzer>, CodeFixProvider, int?, CancellationToken, Document, int, Task<Document>> getFixedDocument, CancellationToken cancellationToken)
{
var document = this.CreateDocument(oldSource, language);
var compilerDiagnostics = await GetCompilerDiagnosticsAsync(document, cancellationToken).ConfigureAwait(false);
document = await getFixedDocument(analyzers, codeFixProvider, codeFixIndex, cancellationToken, document, maxNumberOfIterations).ConfigureAwait(false);
var newCompilerDiagnostics = GetNewDiagnostics(compilerDiagnostics, await GetCompilerDiagnosticsAsync(document, cancellationToken).ConfigureAwait(false));
// check if applying the code fix introduced any new compiler diagnostics
if (!allowNewCompilerDiagnostics && newCompilerDiagnostics.Any())
{
// Format and get the compiler diagnostics again so that the locations make sense in the output
document = await Formatter.FormatAsync(document, Formatter.Annotation, cancellationToken: cancellationToken).ConfigureAwait(false);
newCompilerDiagnostics = GetNewDiagnostics(compilerDiagnostics, await GetCompilerDiagnosticsAsync(document, cancellationToken).ConfigureAwait(false));
string message =
string.Format("Fix introduced new compiler diagnostics:\r\n{0}\r\n\r\nNew document:\r\n{1}\r\n",
string.Join("\r\n", newCompilerDiagnostics.Select(d => d.ToString())),
(await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false)).ToFullString());
Assert.True(false, message);
}
// after applying all of the code fixes, compare the resulting string to the inputted one
var actual = await GetStringFromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
Assert.Equal(newSource, actual);
}
public PathSyntaxReference(SyntaxNode node)
{
_tree = node.SyntaxTree;
_kind = node.Kind();
_textSpan = node.Span;
_pathFromRoot = ComputePathFromRoot(node);
}
public static PatternSearch Create(string text, ImmutableArray<PatternVariable> variables)
{
if (text == null)
throw new ArgumentNullException(nameof(text));
return new PatternSearch(text, variables);
}
protected IList<SyntaxNode> GetExpectedDescendants(IEnumerable<SyntaxNode> nodes, ImmutableArray<SyntaxKind> expected)
{
var descendants = new List<SyntaxNode>();
foreach (var node in nodes)
{
if (expected.Any(e => e == node.Kind()))
{
descendants.Add(node);
continue;
}
foreach (var child in node.ChildNodes())
{
if (expected.Any(e => e == child.Kind()))
{
descendants.Add(child);
continue;
}
if (child.ChildNodes().Count() > 0)
descendants.AddRange(GetExpectedDescendants(child.ChildNodes(), expected));
}
}
return descendants;
}
protected Info ProcessCode(DiagnosticAnalyzer analyzer, string sampleProgram,
ImmutableArray<SyntaxKind> expected, bool allowBuildErrors = false)
{
var options = new CSharpParseOptions(kind: SourceCodeKind.Script); //, languageVersion: LanguageVersion.CSharp5);
var tree = CSharpSyntaxTree.ParseText(sampleProgram, options);
var compilation = CSharpCompilation.Create("Test", new[] { tree }, references);
var diagnostics = compilation.GetDiagnostics();
if (diagnostics.Count(d => d.Severity == DiagnosticSeverity.Error) > 0)
{
var msg = "There were Errors in the sample code\n";
if (allowBuildErrors == false)
Assert.Fail(msg + string.Join("\n", diagnostics));
else
Console.WriteLine(msg + string.Join("\n", diagnostics));
}
var semanticModel = compilation.GetSemanticModel(tree);
var matches = GetExpectedDescendants(tree.GetRoot().ChildNodes(), expected);
// Run the code tree through the analyzer and record the allocations it reports
var compilationWithAnalyzers = compilation.WithAnalyzers(ImmutableArray.Create(analyzer));
var allocations = compilationWithAnalyzers.GetAnalyzerDiagnosticsAsync().GetAwaiter().GetResult().Distinct(DiagnosticEqualityComparer.Instance).ToList();
return new Info
{
Options = options,
Tree = tree,
Compilation = compilation,
Diagnostics = diagnostics,
SemanticModel = semanticModel,
Matches = matches,
Allocations = allocations,
};
}
private static ImmutableArray<DiagnosticData> FilterSuppressedDiagnostics(ImmutableArray<DiagnosticData> diagnostics, bool includeSuppressedDiagnostics)
{
if (includeSuppressedDiagnostics || diagnostics.IsDefaultOrEmpty)
{
return diagnostics;
}
ImmutableArray<DiagnosticData>.Builder builder = null;
for (int i = 0; i < diagnostics.Length; i++)
{
var diagnostic = diagnostics[i];
if (diagnostic.IsSuppressed)
{
if (builder == null)
{
builder = ImmutableArray.CreateBuilder<DiagnosticData>();
for (int j = 0; j < i; j++)
{
builder.Add(diagnostics[j]);
}
}
}
else if (builder != null)
{
builder.Add(diagnostic);
}
}
return builder != null ? builder.ToImmutable() : diagnostics;
}
public static BracketedParameterListSyntax GenerateBracketedParameterList(
ImmutableArray<IParameterSymbol> parameterDefinitions,
bool isExplicit,
CodeGenerationOptions options)
{
return GenerateBracketedParameterList((IList<IParameterSymbol>)parameterDefinitions, isExplicit, options);
}
public SynthesizedImplementationMethod(
MethodSymbol interfaceMethod,
NamedTypeSymbol implementingType,
string name = null,
bool generateDebugInfo = true,
PropertySymbol associatedProperty = null)
{
//it does not make sense to add methods to substituted types
Debug.Assert(implementingType.IsDefinition);
_name = name ?? ExplicitInterfaceHelpers.GetMemberName(interfaceMethod.Name, interfaceMethod.ContainingType, aliasQualifierOpt: null);
_interfaceMethod = interfaceMethod;
_implementingType = implementingType;
_generateDebugInfo = generateDebugInfo;
_associatedProperty = associatedProperty;
_explicitInterfaceImplementations = ImmutableArray.Create<MethodSymbol>(interfaceMethod);
// alpha-rename to get the implementation's type parameters
var typeMap = interfaceMethod.ContainingType.TypeSubstitution ?? TypeMap.Empty;
typeMap.WithAlphaRename(interfaceMethod, this, out _typeParameters);
var substitutedInterfaceMethod = interfaceMethod.ConstructIfGeneric(_typeParameters.Cast<TypeParameterSymbol, TypeSymbol>());
_returnType = substitutedInterfaceMethod.ReturnType;
_parameters = SynthesizedParameterSymbol.DeriveParameters(substitutedInterfaceMethod, this);
}
public ProjectFileReference(string path, ImmutableArray<string> aliases)
{
Debug.Assert(!aliases.IsDefault);
this.Path = path;
this.Aliases = aliases;
}
public ReferencedAssembly(TAssemblySymbol symbol, ImmutableArray<string> aliases)
{
Debug.Assert(symbol != null && !aliases.IsDefault);
this.Symbol = symbol;
this.Aliases = aliases;
}
public static Block Create(BlockHeader header, ImmutableArray<DecodedTx> transactions)
{
var blockTxes = ImmutableArray.CreateRange(transactions.Select((tx, txIndex) =>
new BlockTx(txIndex, tx)));
return new Block(header, blockTxes);
}
internal InteractiveEvaluator(
IContentType contentType,
HostServices hostServices,
IViewClassifierAggregatorService classifierAggregator,
IInteractiveWindowCommandsFactory commandsFactory,
ImmutableArray<IInteractiveWindowCommand> commands,
string responseFilePath,
string initialWorkingDirectory,
string interactiveHostPath,
Type replType)
{
Debug.Assert(responseFilePath == null || PathUtilities.IsAbsolute(responseFilePath));
_contentType = contentType;
_responseFilePath = responseFilePath;
_workspace = new InteractiveWorkspace(this, hostServices);
_contentTypeChangedHandler = new EventHandler<ContentTypeChangedEventArgs>(LanguageBufferContentTypeChanged);
_classifierAggregator = classifierAggregator;
_initialWorkingDirectory = initialWorkingDirectory;
_commandsFactory = commandsFactory;
_commands = commands;
var hostPath = interactiveHostPath;
_interactiveHost = new InteractiveHost(replType, hostPath, initialWorkingDirectory);
_interactiveHost.ProcessStarting += ProcessStarting;
}
public bool TryGetImageMoniker(ImmutableArray<string> tags, out ImageMoniker imageMoniker)
{
this.AssertIsForeground();
imageMoniker = GetImageMoniker(tags);
return !imageMoniker.IsNullImage();
}
public FileSystemCompletionHelper(
CompletionListProvider completionProvider,
TextSpan textChangeSpan,
ICurrentWorkingDirectoryDiscoveryService fileSystemDiscoveryService,
Glyph folderGlyph,
Glyph fileGlyph,
ImmutableArray<string> searchPaths,
IEnumerable<string> allowableExtensions,
Func<string, bool> exclude = null,
CompletionItemRules itemRules = null)
{
Debug.Assert(searchPaths.All(path => PathUtilities.IsAbsolute(path)));
_completionProvider = completionProvider;
_textChangeSpan = textChangeSpan;
_searchPaths = searchPaths;
_allowableExtensions = allowableExtensions.Select(e => e.ToLowerInvariant()).ToSet();
_fileSystemDiscoveryService = fileSystemDiscoveryService;
_folderGlyph = folderGlyph;
_fileGlyph = fileGlyph;
_exclude = exclude;
_itemRules = itemRules;
_lazyGetDrives = new Lazy<string[]>(() =>
IOUtilities.PerformIO(Directory.GetLogicalDrives, SpecializedCollections.EmptyArray<string>()));
}
public override async Task AddDocumentFixesAsync(Document document, ImmutableArray<Diagnostic> diagnostics, Action<CodeAction> addFix, FixAllContext fixAllContext)
{
var pragmaActionsBuilder = ImmutableArray.CreateBuilder<IPragmaBasedCodeAction>();
var pragmaDiagnosticsBuilder = ImmutableArray.CreateBuilder<Diagnostic>();
foreach (var diagnostic in diagnostics.Where(d => d.Location.IsInSource && !d.IsSuppressed))
{
var span = diagnostic.Location.SourceSpan;
var pragmaSuppressions = await _suppressionFixProvider.GetPragmaSuppressionsAsync(document, span, SpecializedCollections.SingletonEnumerable(diagnostic), fixAllContext.CancellationToken).ConfigureAwait(false);
var pragmaSuppression = pragmaSuppressions.SingleOrDefault();
if (pragmaSuppression != null)
{
if (fixAllContext is FixMultipleContext)
{
pragmaSuppression = pragmaSuppression.CloneForFixMultipleContext();
}
pragmaActionsBuilder.Add(pragmaSuppression);
pragmaDiagnosticsBuilder.Add(diagnostic);
}
}
// Get the pragma batch fix.
if (pragmaActionsBuilder.Count > 0)
{
var pragmaBatchFix = PragmaBatchFixHelpers.CreateBatchPragmaFix(_suppressionFixProvider, document,
pragmaActionsBuilder.ToImmutable(), pragmaDiagnosticsBuilder.ToImmutable(), fixAllContext);
addFix(pragmaBatchFix);
}
}
public override async Task SynchronizeWithBuildAsync(Project project, ImmutableArray<DiagnosticData> diagnostics)
{
if (!PreferBuildErrors(project.Solution.Workspace))
{
// prefer live errors over build errors
return;
}
using (var poolObject = SharedPools.Default<HashSet<string>>().GetPooledObject())
{
var lookup = CreateDiagnosticIdLookup(diagnostics);
foreach (var stateSet in _stateManager.GetStateSets(project))
{
var descriptors = HostAnalyzerManager.GetDiagnosticDescriptors(stateSet.Analyzer);
var liveDiagnostics = ConvertToLiveDiagnostics(lookup, descriptors, poolObject.Object);
// we are using Default so that things like LB can't use cached information
var projectTextVersion = VersionStamp.Default;
var semanticVersion = await project.GetDependentSemanticVersionAsync(CancellationToken.None).ConfigureAwait(false);
var state = stateSet.GetState(StateType.Project);
var existingDiagnostics = await state.TryGetExistingDataAsync(project, CancellationToken.None).ConfigureAwait(false);
var mergedDiagnostics = MergeDiagnostics(liveDiagnostics, GetExistingDiagnostics(existingDiagnostics));
await state.PersistAsync(project, new AnalysisData(projectTextVersion, semanticVersion, mergedDiagnostics), CancellationToken.None).ConfigureAwait(false);
RaiseDiagnosticsUpdated(StateType.Project, project.Id, stateSet, new SolutionArgument(project), mergedDiagnostics);
}
}
}
private TypeMap WithAlphaRename(ImmutableArray<TypeParameterSymbol> oldTypeParameters, Symbol newOwner, out ImmutableArray<TypeParameterSymbol> newTypeParameters)
{
if (oldTypeParameters.Length == 0)
{
newTypeParameters = ImmutableArray<TypeParameterSymbol>.Empty;
return this;
}
// Note: the below assertion doesn't hold while rewriting async lambdas defined inside generic methods.
// The async rewriter adds a synthesized struct inside the lambda frame and construct a typemap from
// the lambda frame's substituted type parameters.
// Debug.Assert(!oldTypeParameters.Any(tp => tp is SubstitutedTypeParameterSymbol));
// warning: we expose result to the SubstitutedTypeParameterSymbol constructor, below, even before it's all filled in.
TypeMap result = new TypeMap(this.Mapping);
ArrayBuilder<TypeParameterSymbol> newTypeParametersBuilder = ArrayBuilder<TypeParameterSymbol>.GetInstance();
// The case where it is "synthesized" is when we're creating type parameters for a synthesized (generic)
// class or method for a lambda appearing in a generic method.
bool synthesized = !ReferenceEquals(oldTypeParameters[0].ContainingSymbol.OriginalDefinition, newOwner.OriginalDefinition);
foreach (var tp in oldTypeParameters)
{
var newTp = synthesized ?
new SynthesizedSubstitutedTypeParameterSymbol(newOwner, result, tp) :
new SubstitutedTypeParameterSymbol(newOwner, result, tp);
result.Mapping.Add(tp, new TypeWithModifiers(newTp));
newTypeParametersBuilder.Add(newTp);
}
newTypeParameters = newTypeParametersBuilder.ToImmutableAndFree();
return result;
}
/// <summary>
/// Determine the effective base type, effective interface set, and set of type
/// parameters (excluding cycles) from the type parameter constraints. Conflicts
/// within the constraints and constraint types are returned as diagnostics.
/// 'inherited' should be true if the type parameters are from an overridden
/// generic method. In those cases, additional constraint checks are applied.
/// </summary>
public static TypeParameterBounds ResolveBounds(
this TypeParameterSymbol typeParameter,
AssemblySymbol corLibrary,
ConsList<TypeParameterSymbol> inProgress,
ImmutableArray<TypeSymbol> constraintTypes,
bool inherited,
CSharpCompilation currentCompilation,
DiagnosticBag diagnostics)
{
var diagnosticsBuilder = ArrayBuilder<TypeParameterDiagnosticInfo>.GetInstance();
ArrayBuilder<TypeParameterDiagnosticInfo> useSiteDiagnosticsBuilder = null;
var bounds = typeParameter.ResolveBounds(corLibrary, inProgress, constraintTypes, inherited, currentCompilation, diagnosticsBuilder, ref useSiteDiagnosticsBuilder);
if (useSiteDiagnosticsBuilder != null)
{
diagnosticsBuilder.AddRange(useSiteDiagnosticsBuilder);
}
foreach (var pair in diagnosticsBuilder)
{
diagnostics.Add(new CSDiagnostic(pair.DiagnosticInfo, pair.TypeParameter.Locations[0]));
}
diagnosticsBuilder.Free();
return bounds;
}
public AddressPayload With(ImmutableArray<NetworkAddressWithTime>? NetworkAddresses = null)
{
return new AddressPayload
(
NetworkAddresses ?? this.NetworkAddresses
);
}
internal SourceAttributeData(
SyntaxReference applicationNode,
NamedTypeSymbol attributeClass,
MethodSymbol attributeConstructor,
ImmutableArray<TypedConstant> constructorArguments,
ImmutableArray<int> constructorArgumentsSourceIndices,
ImmutableArray<KeyValuePair<string, TypedConstant>> namedArguments,
bool hasErrors,
bool isConditionallyOmitted)
{
Debug.Assert(!isConditionallyOmitted || (object)attributeClass != null && attributeClass.IsConditional);
Debug.Assert(!constructorArguments.IsDefault);
Debug.Assert(!namedArguments.IsDefault);
Debug.Assert(constructorArgumentsSourceIndices.IsDefault ||
constructorArgumentsSourceIndices.Any() && constructorArgumentsSourceIndices.Length == constructorArguments.Length);
this.attributeClass = attributeClass;
this.attributeConstructor = attributeConstructor;
this.constructorArguments = constructorArguments;
this.constructorArgumentsSourceIndices = constructorArgumentsSourceIndices;
this.namedArguments = namedArguments;
this.isConditionallyOmitted = isConditionallyOmitted;
this.hasErrors = hasErrors;
this.applicationNode = applicationNode;
}
/// <summary>
/// Create a context for evaluating expressions at a type scope.
/// </summary>
/// <param name="previous">Previous context, if any, for possible re-use.</param>
/// <param name="metadataBlocks">Module metadata</param>
/// <param name="moduleVersionId">Module containing type</param>
/// <param name="typeToken">Type metadata token</param>
/// <returns>Evaluation context</returns>
/// <remarks>
/// No locals since locals are associated with methods, not types.
/// </remarks>
internal static EvaluationContext CreateTypeContext(
CSharpMetadataContext previous,
ImmutableArray<MetadataBlock> metadataBlocks,
Guid moduleVersionId,
int typeToken)
{
Debug.Assert(MetadataTokens.Handle(typeToken).Kind == HandleKind.TypeDefinition);
// Re-use the previous compilation if possible.
var compilation = metadataBlocks.HaveNotChanged(previous) ?
previous.Compilation :
metadataBlocks.ToCompilation();
MetadataDecoder metadataDecoder;
var currentType = compilation.GetType(moduleVersionId, typeToken, out metadataDecoder);
Debug.Assert((object)currentType != null);
Debug.Assert(metadataDecoder != null);
var currentFrame = new SynthesizedContextMethodSymbol(currentType);
return new EvaluationContext(
metadataBlocks,
null,
compilation,
metadataDecoder,
currentFrame,
default(ImmutableArray<LocalSymbol>),
ImmutableSortedSet<int>.Empty,
default(ImmutableArray<ImmutableArray<string>>),
default(ImmutableArray<string>));
}
public NetworkAddressKey(ImmutableArray<byte> IPv6Address, UInt16 Port)
{
this.IPv6Address = IPv6Address;
this.Port = Port;
this._hashCode = Port.GetHashCode() ^ new BigInteger(IPv6Address.ToArray()).GetHashCode();
}
protected override void AppendTodoComments(ImmutableArray<TodoCommentDescriptor> commentDescriptors, SyntacticDocument document, SyntaxTrivia trivia, List<TodoComment> todoList)
{
if (PreprocessorHasComment(trivia))
{
var message = trivia.ToFullString();
var index = message.IndexOf(SingleLineCommentPrefix);
var start = trivia.FullSpan.Start + index;
AppendTodoCommentInfoFromSingleLine(commentDescriptors, document, message.Substring(index), start, todoList);
return;
}
if (IsSingleLineComment(trivia))
{
ProcessMultilineComment(commentDescriptors, document, trivia, postfixLength: 0, todoList: todoList);
return;
}
if (IsMultilineComment(trivia))
{
ProcessMultilineComment(commentDescriptors, document, trivia, s_multilineCommentPostfixLength, todoList);
return;
}
throw ExceptionUtilities.Unreachable;
}
private void WriteTo(Stream stream, ImmutableArray<DiagnosticData> items, CancellationToken cancellationToken)
{
using (var writer = new ObjectWriter(stream, cancellationToken: cancellationToken))
{
writer.WriteInt32(FormatVersion);
AnalyzerVersion.WriteTo(writer);
Version.WriteTo(writer);
writer.WriteInt32(items.Length);
foreach (var item in items)
{
cancellationToken.ThrowIfCancellationRequested();
writer.WriteString(item.Id);
writer.WriteString(item.Category);
writer.WriteString(item.Message);
writer.WriteString(item.ENUMessageForBingSearch);
writer.WriteString(item.Title);
writer.WriteString(item.Description);
writer.WriteString(item.HelpLink);
writer.WriteInt32((int)item.Severity);
writer.WriteInt32((int)item.DefaultSeverity);
writer.WriteBoolean(item.IsEnabledByDefault);
writer.WriteBoolean(item.IsSuppressed);
writer.WriteInt32(item.WarningLevel);
if (item.HasTextSpan)
{
// document state
writer.WriteInt32(item.TextSpan.Start);
writer.WriteInt32(item.TextSpan.Length);
}
else
{
// project state
writer.WriteInt32(0);
writer.WriteInt32(0);
}
WriteTo(writer, item.DataLocation, cancellationToken);
WriteTo(writer, item.AdditionalLocations, cancellationToken);
writer.WriteInt32(item.CustomTags.Count);
foreach (var tag in item.CustomTags)
{
writer.WriteString(tag);
}
writer.WriteInt32(item.Properties.Count);
foreach (var property in item.Properties)
{
writer.WriteString(property.Key);
writer.WriteString(property.Value);
}
}
}
}
/// <summary>
/// Given an analyzer and a collection of documents to apply it to, run the analyzer and gather an array of
/// diagnostics found. The returned diagnostics are then ordered by location in the source documents.
/// </summary>
/// <param name="analyzers">The analyzer to run on the documents.</param>
/// <param name="documents">The <see cref="Document"/>s that the analyzer will be run on.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> that the task will observe.</param>
/// <returns>A collection of <see cref="Diagnostic"/>s that surfaced in the source code, sorted by
/// <see cref="Diagnostic.Location"/>.</returns>
protected static async Task<ImmutableArray<Diagnostic>> GetSortedDiagnosticsFromDocumentsAsync(ImmutableArray<DiagnosticAnalyzer> analyzers, Document[] documents, CancellationToken cancellationToken)
{
var projects = new HashSet<Project>();
foreach (var document in documents)
{
projects.Add(document.Project);
}
var supportedDiagnosticsSpecificOptions = new Dictionary<string, ReportDiagnostic>();
foreach (var analyzer in analyzers)
{
foreach (var diagnostic in analyzer.SupportedDiagnostics)
{
// make sure the analyzers we are testing are enabled
supportedDiagnosticsSpecificOptions[diagnostic.Id] = ReportDiagnostic.Default;
}
}
// Report exceptions during the analysis process as errors
supportedDiagnosticsSpecificOptions.Add("AD0001", ReportDiagnostic.Error);
var diagnostics = ImmutableArray.CreateBuilder<Diagnostic>();
foreach (var project in projects)
{
// update the project compilation options
var modifiedSpecificDiagnosticOptions = supportedDiagnosticsSpecificOptions.ToImmutableDictionary().SetItems(project.CompilationOptions.SpecificDiagnosticOptions);
var modifiedCompilationOptions = project.CompilationOptions.WithSpecificDiagnosticOptions(modifiedSpecificDiagnosticOptions);
var processedProject = project.WithCompilationOptions(modifiedCompilationOptions);
var compilation = await processedProject.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
var compilationWithAnalyzers = compilation.WithAnalyzers(analyzers, processedProject.AnalyzerOptions, cancellationToken);
var compilerDiagnostics = compilation.GetDiagnostics(cancellationToken);
var compilerErrors = compilerDiagnostics.Where(i => i.Severity == DiagnosticSeverity.Error);
var diags = await compilationWithAnalyzers.GetAnalyzerDiagnosticsAsync().ConfigureAwait(false);
var allDiagnostics = await compilationWithAnalyzers.GetAllDiagnosticsAsync().ConfigureAwait(false);
var failureDiagnostics = allDiagnostics.Where(diagnostic => diagnostic.Id == "AD0001");
foreach (var diag in diags.Concat(compilerErrors).Concat(failureDiagnostics))
{
if (diag.Location == Location.None || diag.Location.IsInMetadata)
{
diagnostics.Add(diag);
}
else
{
for (int i = 0; i < documents.Length; i++)
{
var document = documents[i];
var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
if (tree == diag.Location.SourceTree)
{
diagnostics.Add(diag);
}
}
}
}
}
var results = SortDistinctDiagnostics(diagnostics);
return results.ToImmutableArray();
}
public EELocalSymbol(
MethodSymbol method,
ImmutableArray<Location> locations,
string nameOpt,
int ordinal,
LocalDeclarationKind declarationKind,
TypeSymbol type,
RefKind refKind,
bool isPinned,
bool isCompilerGenerated,
bool canScheduleToStack)
{
Debug.Assert(method != null);
Debug.Assert(ordinal >= -1);
Debug.Assert(!locations.IsDefault);
Debug.Assert(type != null);
_method = method;
_locations = locations;
_nameOpt = nameOpt;
_ordinal = ordinal;
_declarationKind = declarationKind;
_type = type;
_refKind = refKind;
_isPinned = isPinned;
_isCompilerGenerated = isCompilerGenerated;
_canScheduleToStack = canScheduleToStack;
}
private static NavInfoNodeEnum CreateEnum(ref ImmutableArray<NavInfoNode> nodes, ImmutableArray<NavInfoNode> baseNodes, bool isCanonical, bool isObjectBrowser)
{
if (nodes.IsDefault)
{
var builder = ImmutableArray.CreateBuilder<NavInfoNode>();
var startIndex = 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 && baseNodes.Length >= 2 && baseNodes[1].ListType == _LIB_LISTTYPE.LLT_HIERARCHY)
{
startIndex = 2;
}
for (int i = startIndex; i < baseNodes.Length; i++)
{
if (isCanonical && baseNodes[i].ListType == _LIB_LISTTYPE.LLT_HIERARCHY)
{
continue;
}
builder.Add(baseNodes[i]);
}
nodes = builder.ToImmutable();
}
return new NavInfoNodeEnum(nodes);
}
public void AllAttributed( ImmutableArray<Type> types )
{
Assert.Equal( 2, types.Length );
var names = types.Select( type => type.FullName ).ToArray();
Assert.Contains( "DragonSpark.Testing.Parts.PublicClass", names );
Assert.Contains( "DragonSpark.Testing.Parts.NonPublicClass", names );
}
public SynthesizedIntrinsicOperatorSymbol(TypeSymbol leftType, string name, TypeSymbol rightType, TypeSymbol returnType, bool isCheckedBuiltin)
{
if (leftType.Equals(rightType, ignoreCustomModifiers: true))
{
this.containingType = leftType;
}
else if (rightType.Equals(returnType, ignoreCustomModifiers: true))
{
this.containingType = rightType;
}
else
{
Debug.Assert(leftType.Equals(returnType, ignoreCustomModifiers: true));
this.containingType = leftType;
}
this.name = name;
this.returnType = returnType;
Debug.Assert((leftType.IsDynamic() || rightType.IsDynamic()) == returnType.IsDynamic());
Debug.Assert(containingType.IsDynamic() == returnType.IsDynamic());
this.parameters = (new ParameterSymbol[] {new SynthesizedOperatorParameterSymbol(this, leftType, 0, "left"),
new SynthesizedOperatorParameterSymbol(this, rightType, 1, "right")}).AsImmutableOrNull();
this.isCheckedBuiltin = isCheckedBuiltin;
}
protected sealed override ImmutableArray <CodeAction> MassageActions(ImmutableArray <CodeAction> actions) => FlattenActions(actions);
public override void RegisterSyntaxNodeAction <TLanguageKindEnum>(Action <SyntaxNodeAnalysisContext> action, ImmutableArray <TLanguageKindEnum> syntaxKinds)
{
}
private void RaiseDocumentDiagnosticsIfNeeded(
TextDocument document, StateSet stateSet, AnalysisKind kind, ImmutableArray <DiagnosticData> oldItems, ImmutableArray <DiagnosticData> newItems)
{
RaiseDocumentDiagnosticsIfNeeded(document, stateSet, kind, oldItems, newItems, AnalyzerService.RaiseDiagnosticsUpdated, forceUpdate: false);
}
private void RaiseDocumentDiagnosticsIfNeeded(TextDocument document, StateSet stateSet, AnalysisKind kind, ImmutableArray <DiagnosticData> items) => RaiseDocumentDiagnosticsIfNeeded(document, stateSet, kind, ImmutableArray <DiagnosticData> .Empty, items);
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddTypeArgument))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
TypeSyntax type = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <TypeSyntax>();
Debug.Assert(type != null, $"{nameof(type)} is null");
if (type == null)
{
return;
}
if (!type.IsKind(SyntaxKind.IdentifierName))
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.UsingGenericTypeRequiresTypeArguments:
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
SymbolInfo symbolInfo = semanticModel.GetSymbolInfo(type, context.CancellationToken);
foreach (ISymbol symbol in symbolInfo.CandidateSymbols)
{
var namedTypeSymbol = symbol as INamedTypeSymbol;
if (namedTypeSymbol != null)
{
ImmutableArray <ITypeParameterSymbol> typeParameters = namedTypeSymbol.TypeParameters;
if (typeParameters.Any())
{
CodeAction codeAction = CodeAction.Create(
GetTitle(typeParameters),
cancellationToken =>
{
SeparatedSyntaxList <TypeSyntax> typeArguments = CreateTypeArguments(typeParameters, type.SpanStart, semanticModel).ToSeparatedSyntaxList();
var identifierName = (IdentifierNameSyntax)type;
GenericNameSyntax newNode = SyntaxFactory.GenericName(identifierName.Identifier, SyntaxFactory.TypeArgumentList(typeArguments));
return(context.Document.ReplaceNodeAsync(type, newNode, context.CancellationToken));
},
GetEquivalenceKey(diagnostic, SymbolDisplay.GetString(namedTypeSymbol)));
context.RegisterCodeFix(codeAction, diagnostic);
}
}
}
break;
}
}
}
}
public void ShadowInvariants()
{
TestHiddenProperty((old, value) => old.WithOutputKind(value), opt => opt.OutputKind, OutputKind.DynamicallyLinkedLibrary);
TestHiddenProperty((old, value) => old.WithModuleName(value), opt => opt.ModuleName, "goo.dll");
TestHiddenProperty((old, value) => old.WithMainTypeName(value), opt => opt.MainTypeName, "Goo.Bar");
TestHiddenProperty((old, value) => old.WithScriptClassName(value), opt => opt.ScriptClassName, "<Script>");
TestHiddenProperty((old, value) => old.WithOptimizationLevel(value), opt => opt.OptimizationLevel, OptimizationLevel.Release);
TestHiddenProperty((old, value) => old.WithOverflowChecks(value), opt => opt.CheckOverflow, true);
TestHiddenProperty((old, value) => old.WithCryptoKeyContainer(value), opt => opt.CryptoKeyContainer, "goo");
TestHiddenProperty((old, value) => old.WithCryptoKeyFile(value), opt => opt.CryptoKeyFile, "goo");
TestHiddenProperty((old, value) => old.WithCryptoPublicKey(value), opt => opt.CryptoPublicKey, ImmutableArray.Create <byte>(0, 1, 2, 3));
TestHiddenProperty((old, value) => old.WithDelaySign(value), opt => opt.DelaySign, true);
TestHiddenProperty((old, value) => old.WithPlatform(value), opt => opt.Platform, Platform.Itanium);
TestHiddenProperty((old, value) => old.WithGeneralDiagnosticOption(value), opt => opt.GeneralDiagnosticOption, ReportDiagnostic.Suppress);
TestHiddenProperty((old, value) => old.WithSpecificDiagnosticOptions(value), opt => opt.SpecificDiagnosticOptions,
new Dictionary <string, ReportDiagnostic> {
{ "CS0001", ReportDiagnostic.Error }
}.ToImmutableDictionary());
TestHiddenProperty((old, value) => old.WithReportSuppressedDiagnostics(value), opt => opt.ReportSuppressedDiagnostics, true);
TestHiddenProperty((old, value) => old.WithConcurrentBuild(value), opt => opt.ConcurrentBuild, false);
TestHiddenProperty((old, value) => old.WithXmlReferenceResolver(value), opt => opt.XmlReferenceResolver, new XmlFileResolver(null));
TestHiddenProperty((old, value) => old.WithMetadataReferenceResolver(value), opt => opt.MetadataReferenceResolver, new TestMetadataReferenceResolver());
TestHiddenProperty((old, value) => old.WithAssemblyIdentityComparer(value), opt => opt.AssemblyIdentityComparer, new DesktopAssemblyIdentityComparer(new AssemblyPortabilityPolicy()));
TestHiddenProperty((old, value) => old.WithStrongNameProvider(value), opt => opt.StrongNameProvider, new DesktopStrongNameProvider());
}
public void Invariants()
{
TestProperty((old, value) => old.WithOutputKind(value), opt => opt.OutputKind, OutputKind.DynamicallyLinkedLibrary);
TestProperty((old, value) => old.WithModuleName(value), opt => opt.ModuleName, "goo.dll");
TestProperty((old, value) => old.WithMainTypeName(value), opt => opt.MainTypeName, "Goo.Bar");
TestProperty((old, value) => old.WithScriptClassName(value), opt => opt.ScriptClassName, "<Script>");
TestProperty((old, value) => old.WithUsings(value), opt => opt.Usings, ImmutableArray.Create("A", "B"));
TestProperty((old, value) => old.WithOptimizationLevel(value), opt => opt.OptimizationLevel, OptimizationLevel.Release);
TestProperty((old, value) => old.WithOverflowChecks(value), opt => opt.CheckOverflow, true);
TestProperty((old, value) => old.WithAllowUnsafe(value), opt => opt.AllowUnsafe, true);
TestProperty((old, value) => old.WithCryptoKeyContainer(value), opt => opt.CryptoKeyContainer, "goo");
TestProperty((old, value) => old.WithCryptoKeyFile(value), opt => opt.CryptoKeyFile, "goo");
TestProperty((old, value) => old.WithCryptoPublicKey(value), opt => opt.CryptoPublicKey, ImmutableArray.Create <byte>(0, 1, 2, 3));
TestProperty((old, value) => old.WithDelaySign(value), opt => opt.DelaySign, true);
TestProperty((old, value) => old.WithPlatform(value), opt => opt.Platform, Platform.Itanium);
TestProperty((old, value) => old.WithGeneralDiagnosticOption(value), opt => opt.GeneralDiagnosticOption, ReportDiagnostic.Suppress);
TestProperty((old, value) => old.WithWarningLevel(value), opt => opt.WarningLevel, 3);
TestProperty((old, value) => old.WithSpecificDiagnosticOptions(value), opt => opt.SpecificDiagnosticOptions,
new Dictionary <string, ReportDiagnostic> {
{ "CS0001", ReportDiagnostic.Error }
}.ToImmutableDictionary());
TestProperty((old, value) => old.WithReportSuppressedDiagnostics(value), opt => opt.ReportSuppressedDiagnostics, true);
TestProperty((old, value) => old.WithConcurrentBuild(value), opt => opt.ConcurrentBuild, false);
TestProperty((old, value) => old.WithCurrentLocalTime(value), opt => opt.CurrentLocalTime, new DateTime(2005, 1, 1));
TestProperty((old, value) => old.WithDebugPlusMode(value), opt => opt.DebugPlusMode, true);
TestProperty((old, value) => old.WithXmlReferenceResolver(value), opt => opt.XmlReferenceResolver, new XmlFileResolver(null));
TestProperty((old, value) => old.WithMetadataReferenceResolver(value), opt => opt.MetadataReferenceResolver, new TestMetadataReferenceResolver());
TestProperty((old, value) => old.WithAssemblyIdentityComparer(value), opt => opt.AssemblyIdentityComparer, new DesktopAssemblyIdentityComparer(new AssemblyPortabilityPolicy()));
TestProperty((old, value) => old.WithStrongNameProvider(value), opt => opt.StrongNameProvider, new DesktopStrongNameProvider());
TestProperty((old, value) => old.WithTopLevelBinderFlags(value), opt => opt.TopLevelBinderFlags, BinderFlags.IgnoreCorLibraryDuplicatedTypes);
TestProperty((old, value) => old.WithMetadataImportOptions(value), opt => opt.MetadataImportOptions, MetadataImportOptions.Internal);
TestProperty((old, value) => old.WithReferencesSupersedeLowerVersions(value), opt => opt.ReferencesSupersedeLowerVersions, true);
TestProperty((old, value) => old.WithNullableContextOptions(value), opt => opt.NullableContextOptions, NullableContextOptions.Enable);
}
private static Task <Document> UpdateDocumentAsync(Document document, Diagnostic diagnostic, CancellationToken cancellationToken) => FixAllAsync(document, ImmutableArray.Create(diagnostic), cancellationToken);
protected override bool TryGetExtensionsFromReference(AnalyzerReference reference, out ImmutableArray <CompletionProvider> extensions)
{
// check whether the analyzer reference knows how to return completion providers directly.
if (reference is ICompletionProviderFactory completionProviderFactory)
{
extensions = completionProviderFactory.GetCompletionProviders();
return(true);
}
extensions = default;
return(false);
}
/// <summary>
/// Register a per-compilation symbol action. This pattern is often used by analyzers that inspect some compilation-level
/// data (such as whether certain analysis-relevant types are, in fact, available due to targeting or other settings)
/// to drive registration of symbol actions.
/// </summary>
/// <param name="action"></param>
/// <param name="symbolKinds"></param>
public override void RegisterSymbolAction(Action <SymbolAnalysisContext> action, ImmutableArray <SymbolKind> symbolKinds)
{
SymbolActions.Add(action, symbolKinds);
}
public bool Equals(ImmutableArray<byte> x, ImmutableArray<byte> y)
{
return x.SequenceEqual(y);
}
public int GetHashCode(ImmutableArray<byte> obj)
{
return obj.GetHashCode();
}
public void Generate(out int asyncCatchHandlerOffset, out ImmutableArray <int> asyncYieldPoints, out ImmutableArray <int> asyncResumePoints)
{
this.GenerateImpl();
Debug.Assert(_asyncCatchHandlerOffset >= 0);
asyncCatchHandlerOffset = _builder.GetILOffsetFromMarker(_asyncCatchHandlerOffset);
ArrayBuilder <int> yieldPoints = _asyncYieldPoints;
ArrayBuilder <int> resumePoints = _asyncResumePoints;
Debug.Assert((yieldPoints == null) == (resumePoints == null));
if (yieldPoints == null)
{
asyncYieldPoints = ImmutableArray <int> .Empty;
asyncResumePoints = ImmutableArray <int> .Empty;
}
else
{
var yieldPointBuilder = ArrayBuilder <int> .GetInstance();
var resumePointBuilder = ArrayBuilder <int> .GetInstance();
int n = yieldPoints.Count;
for (int i = 0; i < n; i++)
{
int yieldOffset = _builder.GetILOffsetFromMarker(yieldPoints[i]);
int resumeOffset = _builder.GetILOffsetFromMarker(resumePoints[i]);
Debug.Assert(resumeOffset >= 0); // resume marker should always be reachable from dispatch
// yield point may not be reachable if the whole
// await is not reachable; we just ignore such awaits
if (yieldOffset > 0)
{
yieldPointBuilder.Add(yieldOffset);
resumePointBuilder.Add(resumeOffset);
}
}
asyncYieldPoints = yieldPointBuilder.ToImmutableAndFree();
asyncResumePoints = resumePointBuilder.ToImmutableAndFree();
yieldPoints.Free();
resumePoints.Free();
}
}
private IList <SerializableNavigateToSearchResult> Convert(
ImmutableArray <INavigateToSearchResult> result)
{
return(result.SelectAsArray(SerializableNavigateToSearchResult.Dehydrate));
}
/// <summary>
/// Returns an instance of the reference with specified aliases.
/// </summary>
/// <param name="aliases">The new aliases for the reference.</param>
/// <exception cref="ArgumentException">Alias is invalid for the metadata kind.</exception>
public new PortableExecutableReference WithAliases(IEnumerable <string> aliases)
{
return(this.WithAliases(ImmutableArray.CreateRange(aliases)));
}
/// <summary>
/// Returns an instance of the reference with specified aliases.
/// </summary>
/// <param name="aliases">The new aliases for the reference.</param>
/// <exception cref="ArgumentException">Alias is invalid for the metadata kind.</exception>
public new PortableExecutableReference WithAliases(ImmutableArray <string> aliases)
{
return(WithProperties(new MetadataReferenceProperties(this.Properties.Kind, aliases, this.Properties.EmbedInteropTypes)));
}
public async Task RolemeAsync(
[Summary("A case-insensitive, space-delimited list of roles to toggle.")][Remainder]
string roles = null)
{
if (string.IsNullOrWhiteSpace(roles))
{
await ReplyAsync(
$"Toggleable roles are:```\n{string.Join("\n", _dataService.RoleMeWhiteList.Select(r => r.Name))}```\n" +
"`Example: >roleme Level Designer Programmer` will give you both `Level Designer` and `Programmer` roles.");
return;
}
var rolesValid = new List <SocketRole>();
foreach (SocketRole role in _dataService.RoleMeWhiteList)
{
Match match = Regex.Match(roles, $@"\b{role.Name}\b", RegexOptions.IgnoreCase);
if (!match.Success)
{
continue;
}
// Finds and removes all occurrences of the whitelisted role in the input string.
while (match.Success)
{
roles = roles.Remove(match.Index, match.Length);
match = Regex.Match(roles, $@"\b{role.Name}\b", RegexOptions.IgnoreCase);
}
rolesValid.Add(role);
}
// Splits the remaining roles not found in the whitelist. Filters out empty elements.
ImmutableArray <string> rolesInvalid = roles.Split(' ').Where(r => !string.IsNullOrWhiteSpace(r)).ToImmutableArray();
var user = (SocketGuildUser)Context.User;
var rolesAdded = new List <SocketRole>();
var rolesRemoved = new List <SocketRole>();
// Updates roles.
foreach (SocketRole role in rolesValid)
{
if (user.Roles.Contains(role))
{
await user.RemoveRoleAsync(role);
rolesRemoved.Add(role);
}
else
{
await user.AddRoleAsync(role);
rolesAdded.Add(role);
}
}
// Builds the response.
var logMessage = new StringBuilder();
var embed = new EmbedBuilder();
embed.WithTitle("`roleme` Results");
embed.WithDescription($"Results of toggled roles for {Context.User.Mention}:");
if (rolesAdded.Any())
{
string name = $"Added ({rolesAdded.Count})";
embed.AddInlineField(name, string.Join("\n", rolesAdded.Select(r => r.Mention)));
logMessage.AppendLine($"{name}\n " + string.Join("\n ", rolesAdded.Select(r => r.Name)));
}
if (rolesRemoved.Any())
{
string name = $"Removed ({rolesRemoved.Count})";
embed.AddInlineField(name, string.Join("\n", rolesRemoved.Select(r => r.Mention)));
logMessage.AppendLine($"{name}\n " + string.Join("\n ", rolesRemoved.Select(r => r.Name)));
}
if (rolesInvalid.Any())
{
string name = $"Failed ({rolesInvalid.Count()})";
embed.AddInlineField(name, string.Join("\n", rolesInvalid));
embed.WithFooter("Failures occur when roles don't exist or toggling them is disallowed.");
logMessage.Append($"{name}\n " + string.Join("\n ", rolesInvalid));
}
await ReplyAsync(string.Empty, false, embed.Build());
await _dataService.ChannelLog($"Toggled Roles for {Context.User}", logMessage.ToString());
await DataBaseUtil.AddCommandAsync("RoleMe", Context);
}
protected abstract ImmutableArray<SyntaxNode> MergeImports(ImmutableArray<SyntaxNode> unnecessaryImports);
/// <summary>
/// Given an analyzer and a document to apply it to, run the analyzer and gather an array of diagnostics found in it.
/// The returned diagnostics are then ordered by location in the source document.
/// </summary>
/// <param name="analyzer">The analyzer to run on the documents</param>
/// <param name="documents">The Documents that the analyzer will be run on</param>
/// <returns>An IEnumerable of Diagnostics that surfaced in the source code, sorted by Location</returns>
protected static Diagnostic[] GetSortedDiagnosticsFromDocuments(DiagnosticAnalyzer analyzer, Document[] documents)
{
var projects = new HashSet <Project>();
foreach (var document in documents)
{
projects.Add(document.Project);
}
var diagnostics = new List <Diagnostic>();
foreach (var project in projects)
{
var compilationWithAnalyzers = project.GetCompilationAsync().Result.WithAnalyzers(ImmutableArray.Create(analyzer));
var diags = compilationWithAnalyzers.GetAnalyzerDiagnosticsAsync().Result;
foreach (var diag in diags)
{
if (diag.Location == Location.None || diag.Location.IsInMetadata)
{
diagnostics.Add(diag);
}
else
{
for (int i = 0; i < documents.Length; i++)
{
var document = documents[i];
var tree = document.GetSyntaxTreeAsync().Result;
if (tree == diag.Location.SourceTree)
{
diagnostics.Add(diag);
}
}
}
}
}
var results = SortDiagnostics(diagnostics);
diagnostics.Clear();
return(results);
}
private B2BPartnerContentResponse(ImmutableArray <Outputs.BusinessIdentityResponse> businessIdentities)
{
BusinessIdentities = businessIdentities;
}
/// <summary>
/// Constructs a new parameter collection.
/// </summary>
/// <param name="nodeReferences">The source parameters.</param>
internal ParameterCollection(ImmutableArray <Parameter> nodeReferences)
{
parameters = nodeReferences;
}
internal static ConcatImmutableArray <T> ConcatFast <T>(this ImmutableArray <T> first, ImmutableArray <T> second)
{
return(new ConcatImmutableArray <T>(first, second));
}
internal static bool Contains <T>(this ImmutableArray <T> items, T item, IEqualityComparer <T>?equalityComparer) => items.IndexOf(item, 0, equalityComparer) >= 0;
private GetDiskResult(
bool?burstingEnabled,
Outputs.CreationDataResponse creationData,
string?diskAccessId,
double?diskIOPSReadOnly,
double?diskIOPSReadWrite,
double?diskMBpsReadOnly,
double?diskMBpsReadWrite,
double diskSizeBytes,
int?diskSizeGB,
string diskState,
Outputs.EncryptionResponse?encryption,
Outputs.EncryptionSettingsCollectionResponse?encryptionSettingsCollection,
Outputs.ExtendedLocationResponse?extendedLocation,
string?hyperVGeneration,
string id,
string location,
string managedBy,
ImmutableArray <string> managedByExtended,
int?maxShares,
string name,
string?networkAccessPolicy,
string?osType,
string provisioningState,
Outputs.PurchasePlanResponse?purchasePlan,
ImmutableArray <Outputs.ShareInfoElementResponse> shareInfo,
Outputs.DiskSkuResponse?sku,
ImmutableDictionary <string, string>?tags,
string?tier,
string timeCreated,
string type,
string uniqueId,
ImmutableArray <string> zones)
{
BurstingEnabled = burstingEnabled;
CreationData = creationData;
DiskAccessId = diskAccessId;
DiskIOPSReadOnly = diskIOPSReadOnly;
DiskIOPSReadWrite = diskIOPSReadWrite;
DiskMBpsReadOnly = diskMBpsReadOnly;
DiskMBpsReadWrite = diskMBpsReadWrite;
DiskSizeBytes = diskSizeBytes;
DiskSizeGB = diskSizeGB;
DiskState = diskState;
Encryption = encryption;
EncryptionSettingsCollection = encryptionSettingsCollection;
ExtendedLocation = extendedLocation;
HyperVGeneration = hyperVGeneration;
Id = id;
Location = location;
ManagedBy = managedBy;
ManagedByExtended = managedByExtended;
MaxShares = maxShares;
Name = name;
NetworkAccessPolicy = networkAccessPolicy;
OsType = osType;
ProvisioningState = provisioningState;
PurchasePlan = purchasePlan;
ShareInfo = shareInfo;
Sku = sku;
Tags = tags;
Tier = tier;
TimeCreated = timeCreated;
Type = type;
UniqueId = uniqueId;
Zones = zones;
}
private BKTree(char[] concatenatedLowerCaseWords, ImmutableArray<Node> nodes, ImmutableArray<Edge> edges)
{
_concatenatedLowerCaseWords = concatenatedLowerCaseWords;
_nodes = nodes;
_edges = edges;
}
internal static ImmutableArray <T> ToImmutableArrayOrEmpty <T>(this ImmutableArray <T> items) => items.IsDefault ? ImmutableArray <T> .Empty : items;
/// <summary>
/// Constructs a new parameter enumerator.
/// </summary>
/// <param name="arguments">The parent source array.</param>
internal Enumerator(ImmutableArray <Parameter> arguments)
{
parameters = arguments;
enumerator = parameters.GetEnumerator();
}
protected virtual async Task AddDocumentFixesAsync(
Document document, ImmutableArray <Diagnostic> diagnostics,
ConcurrentBag <(Diagnostic diagnostic, CodeAction action)> fixes,
private ImmutableArray <CodeRefactoring> FilterOnUIThread(ImmutableArray <CodeRefactoring> refactorings, Workspace workspace)
{
return(refactorings.Select(r => FilterOnUIThread(r, workspace)).WhereNotNull().ToImmutableArray());
}
public GetLocalsAssemblyBuilder(LanguageExpressionCompiler language, MethodDef method, ImmutableArray<string> localVariableNames, ImmutableArray<string> parameterNames) {
this.language = language;
sourceMethod = method;
this.localVariableNames = localVariableNames;
this.parameterNames = parameterNames;
methodNameIndex = 0;
lastMethodSig = null;
localAndMethodBuilder = new List<DSEELocalAndMethod>();
if (method.Parameters.Count == 0 && (method.Body?.Variables.Count ?? 0) == 0) {
generatedModule = null;
getLocalsType = null;
}
else {
var methodModule = method.Module;
generatedModule = new ModuleDefUser(Guid.NewGuid().ToString(), Guid.NewGuid(), methodModule.CorLibTypes.AssemblyRef);
generatedModule.RuntimeVersion = methodModule.RuntimeVersion;
generatedModule.Machine = methodModule.Machine;
var asm = new AssemblyDefUser(Guid.NewGuid().ToString());
asm.Modules.Add(generatedModule);
getLocalsType = new TypeDefUser(getLocalsTypeNamespace, getLocalsTypeName, generatedModule.CorLibTypes.Object.TypeDefOrRef);
getLocalsType.Attributes = TypeAttributes.NotPublic | TypeAttributes.AutoLayout | TypeAttributes.Class | TypeAttributes.Abstract | TypeAttributes.Sealed | TypeAttributes.SpecialName | TypeAttributes.BeforeFieldInit | TypeAttributes.AnsiClass;
generatedModule.Types.Add(getLocalsType);
foreach (var gp in method.DeclaringType.GenericParameters)
getLocalsType.GenericParameters.Add(Clone(gp));
}
}