public void Terminate() { foreach (NsScriptThread thread in _threads.AsSpan()) { CommitTerminateThread(thread); } _clock.Stop(); _threads.Clear(); _newThreads.Clear(); }
public void AssertPublicMembersThrow(ArrayBuilder <string?> builder, string?[] array) { // Public methods & properties except for IsClosed Assert.Throws <ObjectDisposedException>(() => builder.Capacity -= 1); Assert.Throws <ObjectDisposedException>(() => builder[0] = "closed"); Assert.Throws <ObjectDisposedException>(() => builder.Add("closed")); Assert.Throws <ObjectDisposedException>(() => builder.AddRange(Enumerable.Repeat("closed", 2))); Assert.Throws <ObjectDisposedException>(() => _ = builder.BinarySearch(0, 4, "element", StringComparer.Ordinal)); Assert.Throws <ObjectDisposedException>(() => _ = builder.BinarySearch("element")); Assert.Throws <ObjectDisposedException>(() => _ = builder.BinarySearch("element", StringComparer.Ordinal)); Assert.Throws <ObjectDisposedException>(() => builder.Clear()); Assert.Throws <ObjectDisposedException>(() => _ = builder.Close()); Assert.Throws <ObjectDisposedException>(() => _ = builder.CloseAndSlice()); Assert.Throws <ObjectDisposedException>(() => _ = builder.CloseAndSlice(1)); Assert.Throws <ObjectDisposedException>(() => _ = builder.CloseAndSlice(1, 1)); Assert.Throws <ObjectDisposedException>(() => _ = builder.Contains("element")); Assert.Throws <ObjectDisposedException>(() => builder.CopyTo(array)); Assert.Throws <ObjectDisposedException>(() => builder.CopyTo(0, array, 0, 4)); Assert.Throws <ObjectDisposedException>(() => builder.CopyTo(array, 0)); Assert.Throws <ObjectDisposedException>(() => builder.EnsureCapacity(12)); Assert.Throws <ObjectDisposedException>(() => _ = builder.GetEnumerator()); Assert.Throws <ObjectDisposedException>(() => _ = builder.IndexOf("element")); Assert.Throws <ObjectDisposedException>(() => _ = builder.IndexOf("element", 0)); Assert.Throws <ObjectDisposedException>(() => _ = builder.IndexOf("element", 0, 4)); Assert.Throws <ObjectDisposedException>(() => builder.Insert(0, "closed")); Assert.Throws <ObjectDisposedException>(() => builder.InsertRange(0, Enumerable.Repeat("closed", 2))); Assert.Throws <ObjectDisposedException>(() => builder.Remove("element")); Assert.Throws <ObjectDisposedException>(() => builder.RemoveAt(2)); Assert.Throws <ObjectDisposedException>(() => builder.RemoveRange(0, 3)); Assert.Throws <ObjectDisposedException>(() => _ = builder.TrimAndClose()); Assert.Throws <ObjectDisposedException>(() => builder.TrimExcess()); }
internal static void FillUsedEnumFields(ArrayBuilder <EnumField> usedFields, ArrayBuilder <EnumField> fields, ulong underlyingValue) { var remaining = underlyingValue; foreach (var field in fields) { var fieldValue = field.Value; if (fieldValue == 0) { continue; // Otherwise, we'd tack the zero flag onto everything. } if ((remaining & fieldValue) == fieldValue) { remaining -= fieldValue; usedFields.Add(field); if (remaining == 0) { break; } } } // The value contained extra bit flags that didn't correspond to any enum field. We will // report "no fields used" here so the Formatter will just display the underlying value. if (remaining != 0) { usedFields.Clear(); } }
private static async Task <ImmutableArray <INavigateToSearchResult> > FindNavigableDeclaredSymbolInfosAsync( Project project, Document searchDocument, PatternMatcher nameMatcher, PatternMatcher containerMatcherOpt, ArrayBuilder <PatternMatch> nameMatches, ArrayBuilder <PatternMatch> containerMatches, CancellationToken cancellationToken) { var result = ArrayBuilder <INavigateToSearchResult> .GetInstance(); foreach (var document in project.Documents) { if (searchDocument != null && document != searchDocument) { continue; } cancellationToken.ThrowIfCancellationRequested(); var declarationInfo = await document.GetSyntaxTreeIndexAsync(cancellationToken).ConfigureAwait(false); foreach (var declaredSymbolInfo in declarationInfo.DeclaredSymbolInfos) { nameMatches.Clear(); containerMatches.Clear(); cancellationToken.ThrowIfCancellationRequested(); if (nameMatcher.AddMatches(declaredSymbolInfo.Name, nameMatches) && containerMatcherOpt?.AddMatches(declaredSymbolInfo.FullyQualifiedContainerName, containerMatches) != false) { result.Add(ConvertResult( declaredSymbolInfo, document, nameMatches, containerMatches)); } } } return(result.ToImmutableAndFree()); }
/// <summary> /// Restore the data saved by SaveTypes /// </summary> public void RestoreTypes() { _classes.Clear(); _classes.Add(_savedClasses.AsSlice()); _pairedBracketTypes.Clear(); _pairedBracketTypes.Add(_savedPairedBracketTypes.AsSlice()); }
/// <summary> /// Save the Types and PairedBracketTypes of this BiDiData /// </summary> /// <remarks> /// This is used when processing embedded style runs with /// BiDiClass overrides. Text layout process saves the data, /// overrides the style runs to neutral, processes the bidi /// data for the entire paragraph and then restores this data /// before processing the embedded runs. /// </remarks> public void SaveTypes() { // Capture the types data _savedClasses.Clear(); _savedClasses.Add(_classes.AsSlice()); _savedPairedBracketTypes.Clear(); _savedPairedBracketTypes.Add(_pairedBracketTypes.AsSlice()); }
public void Clear() { EditsBuffer.Clear(); ReferenceFramesBuffer.Clear(); ComponentRenderQueue.Clear(); UpdatedComponentDiffs.Clear(); _disposedComponentIds.Clear(); _disposedEventHandlerIds.Clear(); }
private void AddConjunct(BoundExpression test) { if (_sideEffectBuilder.Count != 0) { test = _factory.Sequence(ImmutableArray <LocalSymbol> .Empty, _sideEffectBuilder.ToImmutable(), test); _sideEffectBuilder.Clear(); } _conjunctBuilder.Add(test); }
protected static SyntaxTokenList GetUpdatedDeclarationAccessibilityModifiers( ArrayBuilder <SyntaxToken> newModifierTokens, SyntaxTokenList modifiersList, Func <SyntaxToken, bool> isAccessibilityModifier) { using var _ = ArrayBuilder <SyntaxToken> .GetInstance(out var updatedModifiersList); var anyAccessModifierSeen = false; foreach (var modifier in modifiersList) { SyntaxToken newModifier; if (isAccessibilityModifier(modifier)) { if (newModifierTokens.Count == 0) { continue; } newModifier = newModifierTokens[0] .WithLeadingTrivia(modifier.LeadingTrivia) .WithTrailingTrivia(modifier.TrailingTrivia); newModifierTokens.RemoveAt(0); anyAccessModifierSeen = true; } else { if (anyAccessModifierSeen && newModifierTokens.Any()) { updatedModifiersList.AddRange(newModifierTokens); newModifierTokens.Clear(); } newModifier = modifier; } updatedModifiersList.Add(newModifier); } if (!anyAccessModifierSeen) { for (var i = newModifierTokens.Count - 1; i >= 0; i--) { updatedModifiersList.Insert(0, newModifierTokens[i]); } } else { updatedModifiersList.AddRange(newModifierTokens); } return(updatedModifiersList.ToSyntaxTokenList()); }
private void ReleaseExpressionTemps() { if (_expressionTemps?.Count > 0) { // release in reverse order to keep same temps on top of the temp stack if possible for (int i = _expressionTemps.Count - 1; i >= 0; i--) { var temp = _expressionTemps[i]; FreeTemp(temp); } _expressionTemps.Clear(); } }
private void ClassifyToken(SyntaxToken token) { if (token.Span.IntersectsWith(_textSpan) && _service._syntaxTokenKinds.Contains(token.RawKind)) { _classifierBuffer.Clear(); var context = new EmbeddedLanguageClassificationContext( _project, _semanticModel, token, _options, _result, _cancellationToken); // First, see if this is a string annotated with either a comment or [StringSyntax] attribute. If // so, delegate to the first classifier we have registered for whatever language ID we find. if (_service._detector.IsEmbeddedLanguageToken(token, _semanticModel, _cancellationToken, out var identifier, out _) && _service._identifierToClassifiers.TryGetValue(identifier, out var classifiers)) { foreach (var classifier in classifiers) { // keep track of what classifiers we've run so we don't call into them multiple times. _classifierBuffer.Add(classifier.Value); // If this classifier added values then need to check the other ones. if (TryClassify(classifier.Value, context)) { return; } } } // It wasn't an annotated API. See if it's some legacy API our historical classifiers have direct // support for (for example, .net APIs prior to Net6). foreach (var legacyClassifier in _service._legacyClassifiers) { // don't bother trying to classify again if we already tried above. if (_classifierBuffer.Contains(legacyClassifier.Value)) { continue; } // If this classifier added values then need to check the other ones. if (TryClassify(legacyClassifier.Value, context)) { return; } } // Finally, give the fallback classifier a chance to classify basic language escapes. TryClassify(_service._fallbackClassifier, context); } }
private static void AddResultIfMatch( Document document, DeclaredSymbolInfo declaredSymbolInfo, PatternMatcher nameMatcher, PatternMatcher containerMatcherOpt, ArrayBuilder <PatternMatch> nameMatches, ArrayBuilder <PatternMatch> containerMatches, ArrayBuilder <SearchResult> result, CancellationToken cancellationToken) { nameMatches.Clear(); containerMatches.Clear(); cancellationToken.ThrowIfCancellationRequested(); if (nameMatcher.AddMatches(declaredSymbolInfo.Name, nameMatches) && containerMatcherOpt?.AddMatches(declaredSymbolInfo.FullyQualifiedContainerName, containerMatches) != false) { result.Add(ConvertResult( declaredSymbolInfo, document, nameMatches, containerMatches)); } }
private ImmutableArray <TItem> GetNextBatchAndResetQueue() { lock (_gate) { var result = ArrayBuilder <TItem> .GetInstance(); result.AddRange(_nextBatch); // mark there being no existing update task so that the next OOP notification will // kick one off. _nextBatch.Clear(); _uniqueItems.Clear(); _taskInFlight = false; return(result.ToImmutableAndFree()); } }
internal override ReadOnlyCollection <byte> CompileGetLocals( ArrayBuilder <LocalAndMethod> locals, bool argumentsOnly, ImmutableArray <Alias> aliases, DiagnosticBag diagnostics, out string typeName, Microsoft.CodeAnalysis.CodeGen.CompilationTestData testData) { var context = this.CreateCompilationContext(); var moduleBuilder = context.CompileGetLocals(TypeName, locals, argumentsOnly, aliases, testData, diagnostics); ReadOnlyCollection <byte> assembly = null; if ((moduleBuilder != null) && (locals.Count > 0)) { using (var stream = new MemoryStream()) { Cci.PeWriter.WritePeToStream( new EmitContext(moduleBuilder, null, diagnostics, metadataOnly: false, includePrivateMembers: true), context.MessageProvider, () => stream, getPortablePdbStreamOpt: null, nativePdbWriterOpt: null, pdbPathOpt: null, metadataOnly: false, isDeterministic: false, emitTestCoverageData: false, privateKeyOpt: null, cancellationToken: default(CancellationToken)); if (!diagnostics.HasAnyErrors()) { assembly = new ReadOnlyCollection <byte>(stream.ToArray()); } } } if (assembly == null) { locals.Clear(); assembly = s_emptyBytes; } typeName = TypeName; return(assembly); }
private static void FillCollisionIndices( ArrayBuilder <string> names, string name, bool isCaseSensitive, ArrayBuilder <int> collisionIndices) { collisionIndices.Clear(); var comparer = isCaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase; for (int i = 0, n = names.Count; i < n; i++) { if (comparer.Equals(names[i], name)) { collisionIndices.Add(i); } } }
internal override ReadOnlyCollection <byte> CompileGetLocals( ArrayBuilder <LocalAndMethod> locals, bool argumentsOnly, out string typeName, Microsoft.CodeAnalysis.CodeGen.CompilationTestData testData = null) { var diagnostics = DiagnosticBag.GetInstance(); var context = this.CreateCompilationContext(null); var moduleBuilder = context.CompileGetLocals(TypeName, locals, argumentsOnly, testData, diagnostics); ReadOnlyCollection <byte> assembly = null; if ((moduleBuilder != null) && (locals.Count > 0)) { using (var stream = new MemoryStream()) { Cci.PeWriter.WritePeToStream( new EmitContext((Cci.IModule)moduleBuilder, null, diagnostics), context.MessageProvider, () => stream, nativePdbWriterOpt: null, pdbPathOpt: null, allowMissingMethodBodies: false, deterministic: false, cancellationToken: default(CancellationToken)); if (!diagnostics.HasAnyErrors()) { assembly = new ReadOnlyCollection <byte>(stream.ToArray()); } } } diagnostics.Free(); if (assembly == null) { locals.Clear(); assembly = s_emptyBytes; } typeName = TypeName; return(assembly); }
/// <summary> /// Trim excessive inaccessible text. /// </summary> private static void TrimInaccessibleText(ArrayBuilder <SourceText> segments) { int length, size; ComputeLengthAndStorageSize(segments, out length, out size); // if more than half of the storage is unused, compress into a single new segment if (length < size / 2) { var writer = SourceTextWriter.Create(length); foreach (var segment in segments) { segment.Write(writer); } segments.Clear(); segments.Add(writer.ToSourceText()); } }
/// <summary> /// Trim excessive inaccessible text. /// </summary> private static void TrimInaccessibleText(ArrayBuilder <SourceText> segments) { ComputeLengthAndStorageSize(segments, out int length, out int size); // if more than half of the storage is unused, compress into a single new segment if (length < size / 2) { Encoding encoding = segments[0].Encoding; SourceHashAlgorithm algorithm = segments[0].ChecksumAlgorithm; SourceTextWriter writer = SourceTextWriter.Create(encoding, algorithm, length); foreach (SourceText segment in segments) { segment.Write(writer); } segments.Clear(); segments.Add(writer.ToSourceText()); } }
internal void Tick() { if (!IsRunning) { return; } long?time = null; _newThreads.Clear(); _terminatedThreads.Clear(); foreach (NsScriptThread thread in _threads.AsSpan()) { if (thread.SuspensionTime.HasValue && thread.SleepTimeout.HasValue) { time ??= Ticks; long delta = time.Value - thread.SuspensionTime.Value; if (delta >= thread.SleepTimeout) { CommitResumeThread(thread); } } } }
/// <summary> /// Given a list of method and/or property candidates, choose the first one (if any) with a signature /// that matches the parameter list in the cref. Return null if there isn't one. /// </summary> /// <remarks> /// Produces a diagnostic for ambiguous matches, but not for unresolved members - WRN_BadXMLRef is /// handled in BindMemberCref. /// </remarks> private static ImmutableArray <Symbol> PerformCrefOverloadResolution(ArrayBuilder <Symbol> candidates, ImmutableArray <ParameterSymbol> parameterSymbols, int arity, MemberCrefSyntax memberSyntax, out Symbol ambiguityWinner, DiagnosticBag diagnostics) { ArrayBuilder <Symbol> viable = null; foreach (Symbol candidate in candidates) { // BREAK: In dev11, any candidate with the type "dynamic" anywhere in its parameter list would be skipped // (see XmlDocCommentBinder::bindXmlReference). Apparently, this was because "the params that the xml doc // comments produce never will." This does not appear to have made sense in dev11 (skipping dropping the // candidate doesn't cause anything to blow up and may cause resolution to start succeeding) and it almost // certainly does not in roslyn (the signature comparer ignores the object-dynamic distiction anyway). Symbol signatureMember; switch (candidate.Kind) { case SymbolKind.Method: { MethodSymbol candidateMethod = (MethodSymbol)candidate; MethodKind candidateMethodKind = candidateMethod.MethodKind; bool candidateMethodIsVararg = candidateMethod.IsVararg; // If the arity from the cref is zero, then we accept methods of any arity. int signatureMemberArity = candidateMethodKind == MethodKind.Constructor ? 0 : (arity == 0 ? candidateMethod.Arity : arity); // CONSIDER: we might want to reuse this method symbol (as long as the MethodKind and Vararg-ness match). signatureMember = new SignatureOnlyMethodSymbol( methodKind: candidateMethodKind, typeParameters: IndexedTypeParameterSymbol.Take(signatureMemberArity), parameters: parameterSymbols, // This specific comparer only looks for varargs. callingConvention: candidateMethodIsVararg ? Microsoft.Cci.CallingConvention.ExtraArguments : Microsoft.Cci.CallingConvention.HasThis, // These are ignored by this specific MemberSignatureComparer. containingType: null, name: null, returnType: null, returnTypeCustomModifiers: ImmutableArray <CustomModifier> .Empty, explicitInterfaceImplementations: ImmutableArray <MethodSymbol> .Empty); break; } case SymbolKind.Property: { // CONSIDER: we might want to reuse this property symbol. signatureMember = new SignatureOnlyPropertySymbol( parameters: parameterSymbols, // These are ignored by this specific MemberSignatureComparer. containingType: null, name: null, type: null, typeCustomModifiers: ImmutableArray <CustomModifier> .Empty, isStatic: false, explicitInterfaceImplementations: ImmutableArray <PropertySymbol> .Empty); break; } case SymbolKind.NamedType: // Because we replaced them with constructors when we built the candidate list. throw ExceptionUtilities.UnexpectedValue(candidate.Kind); default: continue; } if (MemberSignatureComparer.CrefComparer.Equals(signatureMember, candidate)) { Debug.Assert(candidate.GetMemberArity() != 0 || candidate.Name == WellKnownMemberNames.InstanceConstructorName || arity == 0, "Can only have a 0-arity, non-constructor candidate if the desired arity is 0."); if (viable == null) { viable = ArrayBuilder <Symbol> .GetInstance(); viable.Add(candidate); } else { bool oldArityIsZero = viable[0].GetMemberArity() == 0; bool newArityIsZero = candidate.GetMemberArity() == 0; // If the cref specified arity 0 and the current candidate has arity 0 but the previous // match did not, then the current candidate is the unambiguous winner (unless there's // another match with arity 0 in a subsequent iteration). if (!oldArityIsZero || newArityIsZero) { if (!oldArityIsZero && newArityIsZero) { viable.Clear(); } viable.Add(candidate); } } } } if (viable == null) { ambiguityWinner = null; return(ImmutableArray <Symbol> .Empty); } if (viable.Count > 1) { ambiguityWinner = viable[0]; CrefSyntax crefSyntax = GetRootCrefSyntax(memberSyntax); diagnostics.Add(ErrorCode.WRN_AmbiguousXMLReference, crefSyntax.Location, crefSyntax.ToString(), ambiguityWinner, viable[1]); } else { ambiguityWinner = null; } return(viable.ToImmutableAndFree()); }
private bool GetUserDefinedOperators(UnaryOperatorKind kind, BoundExpression operand, ArrayBuilder <UnaryOperatorAnalysisResult> results, ref HashSet <DiagnosticInfo> useSiteDiagnostics) { Debug.Assert(operand != null); if ((object)operand.Type == null) { // If the operand has no type -- because it is a null reference or a lambda or a method group -- // there is no way we can determine what type to search for user-defined operators. return(false); } // Spec 7.3.5 Candidate user-defined operators // SPEC: Given a type T and an operation op(A) ... the set of candidate user-defined // SPEC: operators provided by T for op(A) is determined as follows: // SPEC: If T is a nullable type then T0 is its underlying type; otherwise T0 is T. // SPEC: For all operator declarations in T0 and all lifted forms of such operators, if // SPEC: at least one operator is applicable with respect to A then the set of candidate // SPEC: operators consists of all such applicable operators. Otherwise, if T0 is object // SPEC: then the set of candidate operators is empty. Otherwise, the set of candidate // SPEC: operators is the set provided by the direct base class of T0, or the effective // SPEC: base class of T0 if T0 is a type parameter. // https://github.com/dotnet/roslyn/issues/34451: The spec quote should be adjusted to cover operators from interfaces as well. // From https://github.com/dotnet/csharplang/blob/master/meetings/2017/LDM-2017-06-27.md: // - We only even look for operator implementations in interfaces if one of the operands has a type that is an interface or // a type parameter with a non-empty effective base interface list. // - The applicable operators from classes / structs shadow those in interfaces.This matters for constrained type parameters: // the effective base class can shadow operators from effective base interfaces. // - If we find an applicable candidate in an interface, that candidate shadows all applicable operators in base interfaces: // we stop looking. TypeSymbol type0 = operand.Type.StrippedType(); // Searching for user-defined operators is expensive; let's take an early out if we can. if (OperatorFacts.DefinitelyHasNoUserDefinedOperators(type0)) { return(false); } string name = OperatorFacts.UnaryOperatorNameFromOperatorKind(kind); var operators = ArrayBuilder <UnaryOperatorSignature> .GetInstance(); bool hadApplicableCandidates = false; NamedTypeSymbol current = type0 as NamedTypeSymbol; if ((object)current == null) { current = type0.BaseTypeWithDefinitionUseSiteDiagnostics(ref useSiteDiagnostics); } if ((object)current == null && type0.IsTypeParameter()) { current = ((TypeParameterSymbol)type0).EffectiveBaseClass(ref useSiteDiagnostics); } for (; (object)current != null; current = current.BaseTypeWithDefinitionUseSiteDiagnostics(ref useSiteDiagnostics)) { operators.Clear(); GetUserDefinedUnaryOperatorsFromType(current, kind, name, operators); results.Clear(); if (CandidateOperators(operators, operand, results, ref useSiteDiagnostics)) { hadApplicableCandidates = true; break; } } // Look in base interfaces, or effective interfaces for type parameters if (!hadApplicableCandidates) { ImmutableArray <NamedTypeSymbol> interfaces = default; if (type0.IsInterfaceType()) { interfaces = type0.AllInterfacesWithDefinitionUseSiteDiagnostics(ref useSiteDiagnostics); } else if (type0.IsTypeParameter()) { interfaces = ((TypeParameterSymbol)type0).AllEffectiveInterfacesWithDefinitionUseSiteDiagnostics(ref useSiteDiagnostics); } if (!interfaces.IsDefaultOrEmpty) { var shadowedInterfaces = PooledHashSet <NamedTypeSymbol> .GetInstance(); var resultsFromInterface = ArrayBuilder <UnaryOperatorAnalysisResult> .GetInstance(); results.Clear(); foreach (NamedTypeSymbol @interface in interfaces) { if ([email protected]) { // this code could be reachable in error situations continue; } if (shadowedInterfaces.Contains(@interface)) { // this interface is "shadowed" by a derived interface continue; } operators.Clear(); resultsFromInterface.Clear(); GetUserDefinedUnaryOperatorsFromType(@interface, kind, name, operators); if (CandidateOperators(operators, operand, resultsFromInterface, ref useSiteDiagnostics)) { hadApplicableCandidates = true; results.AddRange(resultsFromInterface); // this interface "shadows" all its base interfaces shadowedInterfaces.AddAll(@interface.AllInterfacesWithDefinitionUseSiteDiagnostics(ref useSiteDiagnostics)); } } shadowedInterfaces.Free(); resultsFromInterface.Free(); } } operators.Free(); return(hadApplicableCandidates); }
private static void MergeReducedAndFilteredMethodGroupSymbol( ArrayBuilder<MethodSymbol> methods, ArrayBuilder<MethodSymbol> filteredMethods, SingleLookupResult singleResult, ImmutableArray<TypeSymbol> typeArguments, TypeSymbol receiverType, ref LookupResultKind resultKind) { Debug.Assert(singleResult.Kind != LookupResultKind.Empty); Debug.Assert((object)singleResult.Symbol != null); Debug.Assert(singleResult.Symbol.Kind == SymbolKind.Method); var singleKind = singleResult.Kind; if (resultKind > singleKind) { return; } else if (resultKind < singleKind) { methods.Clear(); filteredMethods.Clear(); resultKind = LookupResultKind.Empty; } var method = (MethodSymbol)singleResult.Symbol; if (AddReducedAndFilteredMethodGroupSymbol(methods, filteredMethods, method, typeArguments, receiverType)) { Debug.Assert(methods.Count > 0); if (resultKind < singleKind) { resultKind = singleKind; } } Debug.Assert((methods.Count == 0) == (resultKind == LookupResultKind.Empty)); Debug.Assert(methods.Count == filteredMethods.Count); }
// Returns true if there were any applicable candidates. private bool GetUserDefinedOperators(UnaryOperatorKind kind, BoundExpression operand, ArrayBuilder<UnaryOperatorAnalysisResult> results, ref HashSet<DiagnosticInfo> useSiteDiagnostics) { Debug.Assert(operand != null); if ((object)operand.Type == null) { // If the operand has no type -- because it is a null reference or a lambda or a method group -- // there is no way we can determine what type to search for user-defined operators. return false; } // Spec 7.3.5 Candidate user-defined operators // SPEC: Given a type T and an operation op(A) ... the set of candidate user-defined // SPEC: operators provided by T for op(A) is determined as follows: // SPEC: If T is a nullable type then T0 is its underlying type; otherwise T0 is T. // SPEC: For all operator declarations in T0 and all lifted forms of such operators, if // SPEC: at least one operator is applicable with respect to A then the set of candidate // SPEC: operators consists of all such applicable operators. Otherwise, if T0 is object // SPEC: then the set of candidate operators is empty. Otherwise, the set of candidate // SPEC: operators is the set provided by the direct base class of T0, or the effective // SPEC: base class of T0 if T0 is a type parameter. TypeSymbol type0 = operand.Type.StrippedType(); // Searching for user-defined operators is expensive; let's take an early out if we can. if (OperatorFacts.DefinitelyHasNoUserDefinedOperators(type0)) { return false; } string name = OperatorFacts.UnaryOperatorNameFromOperatorKind(kind); var operators = ArrayBuilder<UnaryOperatorSignature>.GetInstance(); bool hadApplicableCandidates = false; NamedTypeSymbol current = type0 as NamedTypeSymbol; if ((object)current == null) { current = type0.BaseTypeWithDefinitionUseSiteDiagnostics(ref useSiteDiagnostics); } if ((object)current == null && type0.IsTypeParameter()) { current = ((TypeParameterSymbol)type0).EffectiveBaseClass(ref useSiteDiagnostics); } for (; (object)current != null; current = current.BaseTypeWithDefinitionUseSiteDiagnostics(ref useSiteDiagnostics)) { operators.Clear(); GetUserDefinedUnaryOperatorsFromType(current, kind, name, operators); results.Clear(); if (CandidateOperators(operators, operand, results, ref useSiteDiagnostics)) { hadApplicableCandidates = true; break; } } operators.Free(); return hadApplicableCandidates; }
/// <summary> /// Get the import strings for a given method, following forward pointers as necessary. /// </summary> /// <returns> /// For each namespace enclosing the method, a list of import strings, innermost to outermost. /// There should always be at least one entry, for the global namespace. /// </returns> public static ImmutableArray <ImmutableArray <string> > GetCSharpGroupedImportStrings(this ISymUnmanagedReader reader, int methodToken, int methodVersion, out ImmutableArray <string> externAliasStrings) { externAliasStrings = default(ImmutableArray <string>); ImmutableArray <short> groupSizes = default(ImmutableArray <short>); bool seenForward = false; RETRY: byte[] bytes = reader.GetCustomDebugInfo(methodToken, methodVersion); if (bytes == null) { return(default(ImmutableArray <ImmutableArray <string> >)); } foreach (var record in GetCustomDebugInfoRecords(bytes)) { switch (record.Kind) { case CustomDebugInfoKind.UsingInfo: if (!groupSizes.IsDefault) { throw new InvalidOperationException(string.Format("Expected at most one Using record for method {0}", FormatMethodToken(methodToken))); } groupSizes = DecodeUsingRecord(record.Data); break; case CustomDebugInfoKind.ForwardInfo: if (!externAliasStrings.IsDefault) { throw new InvalidOperationException(string.Format("Did not expect both Forward and ForwardToModule records for method {0}", FormatMethodToken(methodToken))); } methodToken = DecodeForwardRecord(record.Data); // Follow at most one forward link (as in FUNCBRECEE::ensureNamespaces). // NOTE: Dev11 may produce chains of forward links (e.g. for System.Collections.Immutable). if (!seenForward) { seenForward = true; goto RETRY; } break; case CustomDebugInfoKind.ForwardToModuleInfo: if (!externAliasStrings.IsDefault) { throw new InvalidOperationException(string.Format("Expected at most one ForwardToModule record for method {0}", FormatMethodToken(methodToken))); } int moduleInfoMethodToken = DecodeForwardToModuleRecord(record.Data); ImmutableArray <string> allModuleInfoImportStrings = reader.GetMethodByVersion(moduleInfoMethodToken, methodVersion).GetImportStrings(); ArrayBuilder <string> externAliasBuilder = ArrayBuilder <string> .GetInstance(); foreach (string importString in allModuleInfoImportStrings) { if (IsCSharpExternAliasInfo(importString)) { externAliasBuilder.Add(importString); } } externAliasStrings = externAliasBuilder.ToImmutableAndFree(); break; } } if (groupSizes.IsDefault) { // This can happen in malformed PDBs (e.g. chains of forwards). return(default(ImmutableArray <ImmutableArray <string> >)); } var method = reader.GetMethodByVersion(methodToken, methodVersion); if (method == null) { return(default(ImmutableArray <ImmutableArray <string> >)); } ImmutableArray <string> importStrings = method.GetImportStrings(); int numImportStrings = importStrings.Length; ArrayBuilder <ImmutableArray <string> > resultBuilder = ArrayBuilder <ImmutableArray <string> > .GetInstance(groupSizes.Length); ArrayBuilder <string> groupBuilder = ArrayBuilder <string> .GetInstance(); int pos = 0; foreach (short groupSize in groupSizes) { for (int i = 0; i < groupSize; i++, pos++) { if (pos >= numImportStrings) { throw new InvalidOperationException(string.Format("Group size indicates more imports than there are import strings (method {0}).", FormatMethodToken(methodToken))); } string importString = importStrings[pos]; if (IsCSharpExternAliasInfo(importString)) { throw new InvalidOperationException(string.Format("Encountered extern alias info before all import strings were consumed (method {0}).", FormatMethodToken(methodToken))); } groupBuilder.Add(importString); } resultBuilder.Add(groupBuilder.ToImmutable()); groupBuilder.Clear(); } if (externAliasStrings.IsDefault) { Debug.Assert(groupBuilder.Count == 0); // Extern alias detail strings (prefix "Z") are not included in the group counts. for (; pos < numImportStrings; pos++) { string importString = importStrings[pos]; if (!IsCSharpExternAliasInfo(importString)) { throw new InvalidOperationException(string.Format("Expected only extern alias info strings after consuming the indicated number of imports (method {0}).", FormatMethodToken(methodToken))); } groupBuilder.Add(importString); } externAliasStrings = groupBuilder.ToImmutableAndFree(); } else { groupBuilder.Free(); if (pos < numImportStrings) { throw new InvalidOperationException(string.Format("Group size indicates fewer imports than there are import strings (method {0}).", FormatMethodToken(methodToken))); } } return(resultBuilder.ToImmutableAndFree()); }
internal void Clear() { _kind = LookupResultKind.Empty; _symbolList.Clear(); _error = null; }
/// <summary> /// Get the import strings for a given method, following forward pointers as necessary. /// </summary> /// <returns> /// For each namespace enclosing the method, a list of import strings, innermost to outermost. /// There should always be at least one entry, for the global namespace. /// </returns> public static ImmutableArray <ImmutableArray <string> > GetCSharpGroupedImportStrings(this ISymUnmanagedReader reader, int methodToken, out ImmutableArray <string> externAliasStrings) { externAliasStrings = default(ImmutableArray <string>); ImmutableArray <short> groupSizes = default(ImmutableArray <short>); bool seenForward = false; RETRY: var bytes = reader.GetCustomDebugInfo(methodToken); if (bytes == null) { return(default(ImmutableArray <ImmutableArray <string> >)); } int offset = 0; byte globalVersion; byte unusedGlobalCount; ReadGlobalHeader(bytes, ref offset, out globalVersion, out unusedGlobalCount); CheckVersion(globalVersion, methodToken); while (offset < bytes.Length) { byte version; CustomDebugInfoKind kind; int size; ReadRecordHeader(bytes, ref offset, out version, out kind, out size); CheckVersion(version, methodToken); if (kind == CustomDebugInfoKind.UsingInfo) { if (!groupSizes.IsDefault) { throw new InvalidOperationException(string.Format("Expected at most one Using record for method {0}", FormatMethodToken(methodToken))); } ReadUsingRecord(bytes, ref offset, size, out groupSizes); } else if (kind == CustomDebugInfoKind.ForwardInfo) { if (!externAliasStrings.IsDefault) { throw new InvalidOperationException(string.Format("Did not expect both Forward and ForwardToModule records for method {0}", FormatMethodToken(methodToken))); } ReadForwardRecord(bytes, ref offset, size, out methodToken); if (!seenForward) // Follow at most one forward link. { seenForward = true; goto RETRY; } } else if (kind == CustomDebugInfoKind.ForwardToModuleInfo) { if (!externAliasStrings.IsDefault) { throw new InvalidOperationException(string.Format("Expected at most one ForwardToModule record for method {0}", FormatMethodToken(methodToken))); } int moduleInfoMethodToken; ReadForwardToModuleRecord(bytes, ref offset, size, out moduleInfoMethodToken); ImmutableArray <string> allModuleInfoImportStrings = GetImportStrings(reader.GetBaselineMethod(moduleInfoMethodToken)); ArrayBuilder <string> externAliasBuilder = ArrayBuilder <string> .GetInstance(); foreach (string importString in allModuleInfoImportStrings) { if (IsCSharpExternAliasInfo(importString)) { externAliasBuilder.Add(importString); } } externAliasStrings = externAliasBuilder.ToImmutableAndFree(); } else { SkipRecord(bytes, ref offset, size); } } if (groupSizes.IsDefault) { throw new InvalidOperationException(string.Format("Didn't find usings info for method {0}", FormatMethodToken(methodToken))); } ImmutableArray <string> importStrings = GetImportStrings(reader.GetBaselineMethod(methodToken)); int numImportStrings = importStrings.Length; ArrayBuilder <ImmutableArray <string> > resultBuilder = ArrayBuilder <ImmutableArray <string> > .GetInstance(groupSizes.Length); ArrayBuilder <string> groupBuilder = ArrayBuilder <string> .GetInstance(); int pos = 0; foreach (short groupSize in groupSizes) { for (int i = 0; i < groupSize; i++, pos++) { if (pos >= numImportStrings) { throw new InvalidOperationException(string.Format("Group size indicates more imports than there are import strings (method {0}).", FormatMethodToken(methodToken))); } string importString = importStrings[pos]; if (IsCSharpExternAliasInfo(importString)) { throw new InvalidOperationException(string.Format("Encountered extern alias info before all import strings were consumed (method {0}).", FormatMethodToken(methodToken))); } groupBuilder.Add(importString); } resultBuilder.Add(groupBuilder.ToImmutable()); groupBuilder.Clear(); } if (externAliasStrings.IsDefault) { Debug.Assert(groupBuilder.Count == 0); // Extern alias detail strings (prefix "Z") are not included in the group counts. for (; pos < numImportStrings; pos++) { string importString = importStrings[pos]; if (!IsCSharpExternAliasInfo(importString)) { throw new InvalidOperationException(string.Format("Expected only extern alias info strings after consuming the indicated number of imports (method {0}).", FormatMethodToken(methodToken))); } groupBuilder.Add(importString); } externAliasStrings = groupBuilder.ToImmutableAndFree(); } else { groupBuilder.Free(); if (pos < numImportStrings) { throw new InvalidOperationException(string.Format("Group size indicates fewer imports than there are import strings (method {0}).", FormatMethodToken(methodToken))); } } return(resultBuilder.ToImmutableAndFree()); }
public void Clear() { _set.Clear(); _list.Clear(); }
// Returns true if there were any applicable candidates. private bool GetUserDefinedOperators(UnaryOperatorKind kind, BoundExpression operand, ArrayBuilder <UnaryOperatorAnalysisResult> results, ref HashSet <DiagnosticInfo> useSiteDiagnostics) { Debug.Assert(operand != null); if ((object)operand.Type == null) { // If the operand has no type -- because it is a null reference or a lambda or a method group -- // there is no way we can determine what type to search for user-defined operators. return(false); } // Spec 7.3.5 Candidate user-defined operators // SPEC: Given a type T and an operation op(A) ... the set of candidate user-defined // SPEC: operators provided by T for op(A) is determined as follows: // SPEC: If T is a nullable type then T0 is its underlying type; otherwise T0 is T. // SPEC: For all operator declarations in T0 and all lifted forms of such operators, if // SPEC: at least one operator is applicable with respect to A then the set of candidate // SPEC: operators consists of all such applicable operators. Otherwise, if T0 is object // SPEC: then the set of candidate operators is empty. Otherwise, the set of candidate // SPEC: operators is the set provided by the direct base class of T0, or the effective // SPEC: base class of T0 if T0 is a type parameter. TypeSymbol type0 = operand.Type.StrippedType(); // Searching for user-defined operators is expensive; let's take an early out if we can. if (OperatorFacts.DefinitelyHasNoUserDefinedOperators(type0)) { return(false); } string name = OperatorFacts.UnaryOperatorNameFromOperatorKind(kind); var operators = ArrayBuilder <UnaryOperatorSignature> .GetInstance(); bool hadApplicableCandidates = false; NamedTypeSymbol current = type0 as NamedTypeSymbol; if ((object)current == null) { current = type0.BaseTypeWithDefinitionUseSiteDiagnostics(ref useSiteDiagnostics); } if ((object)current == null && type0.IsTypeParameter()) { current = ((TypeParameterSymbol)type0).EffectiveBaseClass(ref useSiteDiagnostics); } for (; (object)current != null; current = current.BaseTypeWithDefinitionUseSiteDiagnostics(ref useSiteDiagnostics)) { operators.Clear(); GetUserDefinedUnaryOperatorsFromType(current, kind, name, operators); results.Clear(); if (CandidateOperators(operators, operand, results, ref useSiteDiagnostics)) { hadApplicableCandidates = true; break; } } operators.Free(); return(hadApplicableCandidates); }
static void Main(string[] args) { Console.WriteLine("Hello World!"); using var portableDeviceManager = new PortableDeviceManager(); portableDeviceManager.GetDevices(); int i; for (i = 0; i < portableDeviceManager.PortableDevices.Count; i++) { Console.WriteLine($"{i}: {portableDeviceManager.PortableDevices[i].DeviceFriendlyName}"); } Console.WriteLine("Please choose a device."); if (uint.TryParse(Console.ReadLine(), out uint uintResult) && uintResult < i) { IPortableDevice portableDevice = portableDeviceManager.PortableDevices[(int)uintResult]; portableDevice.Open(new ClientVersion("PortableDeviceTests", 1, 0, 0), new PortableDeviceOpeningOptions(GenericRights.Read | GenericRights.Write, FileShareOptions.Read | FileShareOptions.Write, false)); i = 0; var b = new ArrayBuilder <IPortableDeviceObject>(); foreach (IPortableDeviceObject portableDeviceObject in portableDevice) { if (portableDeviceObject.Type == new Guid(Microsoft.WindowsAPICodePack.PortableDevices.Guids.PropertySystem.ContentType.FunctionalObject)) { _ = b.AddLast(portableDeviceObject); Console.WriteLine($"{i++}: {portableDeviceObject.Name}"); } } Console.WriteLine("Please enter a memory id."); if (uint.TryParse(Console.ReadLine(), out uintResult) && uintResult < i) { i = 0; var enumerable = (IEnumerablePortableDeviceObject)b.ToArray()[(int)uintResult]; b.Clear(); foreach (IPortableDeviceObject portableDeviceObject in enumerable) { if (portableDeviceObject is IPortableDeviceFolder folder) { _ = b.AddLast(folder); Console.WriteLine($"{i++}: {folder.Name}"); } } Console.WriteLine("Enter the id of the action to perform on the device."); Console.WriteLine("0: Transfer content."); Console.WriteLine("1: Delete content."); string _menuId = Console.ReadLine(); if (int.TryParse(_menuId, out int menuId)) { if (menuId == 0) { Console.WriteLine("Please enter the id of the folder to copy the file to."); if (uint.TryParse(Console.ReadLine(), out uintResult) && uintResult < i) { var _folder = (IPortableDeviceFolder)b.ToArray()[(int)uintResult]; b.Clear(); Console.WriteLine("Please enter a file to copy to the portable device."); string path = Console.ReadLine(); Console.WriteLine("Enter the file content type GUID."); string contentType = Console.ReadLine(); if (Guid.TryParse(contentType, out Guid guidContentType)) { Console.WriteLine("Enter the file format GUID."); string format = Console.ReadLine(); if (Guid.TryParse(format, out Guid guidFormat)) { var stream = new FileStream(path, FileMode.Open); uint totalWritten = 0; _folder.PortableDeviceObjectAdded += PortableDevice_PortableDeviceObjectAdded; _folder.TransferTo(stream, 4000, false, guidContentType, guidFormat, written => { Console.WriteLine($"{written} bytes written during the last write operation; {(totalWritten += written)} total. Continue (Y/y: yes; other input: no)?"); return(true); // Console.ReadLine().ToUpper() == "Y" }); } } i = 0; foreach (IPortableDeviceObject file in _folder) { if (file is IPortableDeviceFile _file) { _ = b.AddLast(_file); Console.WriteLine($"{i++}: {_file.Name}"); } } if (uint.TryParse(Console.ReadLine(), out uintResult) && uintResult < i) { var portableDeviceFile = (IPortableDeviceFile)b.ToArray()[(int)uintResult]; b.Clear(); Console.WriteLine("Please enter a destination file."); path = Console.ReadLine(); path = $"{System.IO.Path.GetDirectoryName(path)}\\{Path.GetFileNameWithoutExtension(path)} - Copy{Path.GetExtension(path)}"; uint totalWritten = 0; var stream = new FileStream(path, FileMode.CreateNew); portableDeviceFile.TransferFrom(stream, 4000, false, written => { Console.WriteLine($"Written: {written}; total: {(totalWritten += written)}."); return(true); }); stream.Flush(); stream.Dispose(); } } } else if (menuId == 1) { Console.WriteLine("Please enter the id of the folder of the file to delete."); if (uint.TryParse(Console.ReadLine(), out uintResult) && uintResult < i) { var _folder = (IPortableDeviceFolder)b.ToArray()[(int)uintResult]; b.Clear(); if (_folder.Count == 1) { if (_folder[0] is IPortableDeviceFile item) { _folder.PortableDeviceObjectRemoved += PortableDevice_PortableDeviceObjectRemoved; item.Delete(); } else { Console.WriteLine("The folder of the given id does not contain a file."); } } else { Console.WriteLine("The folder of the given id is empty or contains more than one file."); } } } else { Console.WriteLine("Incorrect menu id."); } } else { Console.WriteLine("Incorrect menu id."); } } } else { Console.WriteLine("Incorrect device id."); } }
/// <summary> /// Gets a temporary level buffer. Used by the text layout process when /// resolving style runs with different BiDiClass. /// </summary> /// <param name="length">Length of the required ExpandableBuffer</param> /// <returns>An uninitialized level ExpandableBuffer</returns> public ArraySlice <sbyte> GetTempLevelBuffer(int length) { _tempLevelBuffer.Clear(); return(_tempLevelBuffer.Add(length, false)); }
internal void LookupExtensionMethodsInUsings( ArrayBuilder <MethodSymbol> methods, string name, int arity, LookupOptions options, bool callerIsSemanticModel) { Debug.Assert(methods.Count == 0); // We need to avoid collecting multiple candidates for an extension method imported both through a namespace and a static class // We will look for duplicates only if both of the following flags are set to true bool seenNamespaceWithExtensionMethods = false; bool seenStaticClassWithExtensionMethods = false; foreach (var nsOrType in this.Usings) { switch (nsOrType.NamespaceOrType.Kind) { case SymbolKind.Namespace: { var count = methods.Count; ((NamespaceSymbol)nsOrType.NamespaceOrType).GetExtensionMethods(methods, name, arity, options); // If we found any extension methods, then consider this using as used. if (methods.Count != count) { MarkImportDirective(nsOrType.UsingDirective, callerIsSemanticModel); seenNamespaceWithExtensionMethods = true; } break; } case SymbolKind.NamedType: { var count = methods.Count; ((NamedTypeSymbol)nsOrType.NamespaceOrType).GetExtensionMethods(methods, name, arity, options); // If we found any extension methods, then consider this using as used. if (methods.Count != count) { MarkImportDirective(nsOrType.UsingDirective, callerIsSemanticModel); seenStaticClassWithExtensionMethods = true; } break; } } } if (seenNamespaceWithExtensionMethods && seenStaticClassWithExtensionMethods) { var methodsNoDuplicates = ArrayBuilder <MethodSymbol> .GetInstance(); methodsNoDuplicates.AddRange(methods.Distinct()); if (methodsNoDuplicates.Count < methods.Count) { methods.Clear(); methods.AddRange(methodsNoDuplicates); } methodsNoDuplicates.Free(); } }
private bool GetUserDefinedOperators( BinaryOperatorKind kind, TypeSymbol type0, BoundExpression left, BoundExpression right, ArrayBuilder<BinaryOperatorAnalysisResult> results, ref HashSet<DiagnosticInfo> useSiteDiagnostics) { // Spec 7.3.5 Candidate user-defined operators // SPEC: Given a type T and an operation operator op(A), where op is an overloadable // SPEC: operator and A is an argument list, the set of candidate user-defined operators // SPEC: provided by T for operator op(A) is determined as follows: // SPEC: Determine the type T0. If T is a nullable type, T0 is its underlying type, // SPEC: otherwise T0 is equal to T. // (The caller has already passed in the stripped type.) // SPEC: For all operator op declarations in T0 and all lifted forms of such operators, // SPEC: if at least one operator is applicable (7.5.3.1) with respect to the argument // SPEC: list A, then the set of candidate operators consists of all such applicable // SPEC: operators in T0. Otherwise, if T0 is object, the set of candidate operators is empty. // SPEC: Otherwise, the set of candidate operators provided by T0 is the set of candidate // SPEC: operators provided by the direct base class of T0, or the effective base class of // SPEC: T0 if T0 is a type parameter. string name = OperatorFacts.BinaryOperatorNameFromOperatorKind(kind); var operators = ArrayBuilder<BinaryOperatorSignature>.GetInstance(); bool hadApplicableCandidates = false; NamedTypeSymbol current = type0 as NamedTypeSymbol; if ((object)current == null) { current = type0.BaseTypeWithDefinitionUseSiteDiagnostics(ref useSiteDiagnostics); } if ((object)current == null && type0.IsTypeParameter()) { current = ((TypeParameterSymbol)type0).EffectiveBaseClass(ref useSiteDiagnostics); } for (; (object)current != null; current = current.BaseTypeWithDefinitionUseSiteDiagnostics(ref useSiteDiagnostics)) { operators.Clear(); GetUserDefinedBinaryOperatorsFromType(current, kind, name, operators); results.Clear(); if (CandidateOperators(operators, left, right, results, ref useSiteDiagnostics)) { hadApplicableCandidates = true; break; } } operators.Free(); return hadApplicableCandidates; }
/// <summary> /// Trim excessive inaccessible text. /// </summary> private static void TrimInaccessibleText(ArrayBuilder<SourceText> segments) { int length, size; ComputeLengthAndStorageSize(segments, out length, out size); // if more than half of the storage is unused, compress into a single new segment if (length < size / 2) { var encoding = segments[0].Encoding; var algorithm = segments[0].ChecksumAlgorithm; var writer = SourceTextWriter.Create(encoding, algorithm, length); foreach (var segment in segments) { segment.Write(writer); } segments.Clear(); segments.Add(writer.ToSourceText()); } }
internal static void FillUsedEnumFields(ArrayBuilder<EnumField> usedFields, ArrayBuilder<EnumField> fields, ulong underlyingValue) { var remaining = underlyingValue; foreach (var field in fields) { var fieldValue = field.Value; if (fieldValue == 0) continue; // Otherwise, we'd tack the zero flag onto everything. if ((remaining & fieldValue) == fieldValue) { remaining -= fieldValue; usedFields.Add(field); if (remaining == 0) break; } } // The value contained extra bit flags that didn't correspond to any enum field. We will // report "no fields used" here so the Formatter will just display the underlying value. if (remaining != 0) { usedFields.Clear(); } }
internal void LookupExtensionMethodsInUsings( ArrayBuilder<MethodSymbol> methods, string name, int arity, LookupOptions options, bool callerIsSemanticModel) { Debug.Assert(methods.Count == 0); // We need to avoid collecting multiple candidates for an extension method imported both through a namespace and a static class // We will look for duplicates only if both of the following flags are set to true bool seenNamespaceWithExtensionMethods = false; bool seenStaticClassWithExtensionMethods = false; foreach (var nsOrType in this.Usings) { switch (nsOrType.NamespaceOrType.Kind) { case SymbolKind.Namespace: { var count = methods.Count; ((NamespaceSymbol)nsOrType.NamespaceOrType).GetExtensionMethods(methods, name, arity, options); // If we found any extension methods, then consider this using as used. if (methods.Count != count) { MarkImportDirective(nsOrType.UsingDirective, callerIsSemanticModel); seenNamespaceWithExtensionMethods = true; } break; } case SymbolKind.NamedType: { var count = methods.Count; ((NamedTypeSymbol)nsOrType.NamespaceOrType).GetExtensionMethods(methods, name, arity, options); // If we found any extension methods, then consider this using as used. if (methods.Count != count) { MarkImportDirective(nsOrType.UsingDirective, callerIsSemanticModel); seenStaticClassWithExtensionMethods = true; } break; } } } if (seenNamespaceWithExtensionMethods && seenStaticClassWithExtensionMethods) { var methodsNoDuplicates = ArrayBuilder<MethodSymbol>.GetInstance(); methodsNoDuplicates.AddRange(methods.Distinct()); if (methodsNoDuplicates.Count < methods.Count) { methods.Clear(); methods.AddRange(methodsNoDuplicates); } methodsNoDuplicates.Free(); } }
internal override ReadOnlyCollection<byte> CompileGetLocals( ReadOnlyCollection<Alias> aliases, ArrayBuilder<LocalAndMethod> locals, bool argumentsOnly, DiagnosticBag diagnostics, out string typeName, Microsoft.CodeAnalysis.CodeGen.CompilationTestData testData) { var context = this.CreateCompilationContext(null); var moduleBuilder = context.CompileGetLocals(aliases, TypeName, locals, argumentsOnly, testData, diagnostics); ReadOnlyCollection<byte> assembly = null; if ((moduleBuilder != null) && (locals.Count > 0)) { using (var stream = new MemoryStream()) { Cci.PeWriter.WritePeToStream( new EmitContext((Cci.IModule)moduleBuilder, null, diagnostics), context.MessageProvider, () => stream, nativePdbWriterOpt: null, pdbPathOpt: null, allowMissingMethodBodies: false, deterministic: false, cancellationToken: default(CancellationToken)); if (!diagnostics.HasAnyErrors()) { assembly = new ReadOnlyCollection<byte>(stream.ToArray()); } } } if (assembly == null) { locals.Clear(); assembly = s_emptyBytes; } typeName = TypeName; return assembly; }
public void Clear() { _entries.Clear(); }