internal sealed override ImmutableArray <Symbol> GetMembersUnordered() { var builder = ArrayBuilder <Symbol> .GetInstance(); if (_unbound) { foreach (var t in OriginalDefinition.GetMembersUnordered()) { if (t.Kind == SymbolKind.NamedType) { builder.Add(((NamedTypeSymbol)t).AsMember(this)); } } } else { foreach (var t in OriginalDefinition.GetMembersUnordered()) { builder.Add(t.SymbolAsMember(this)); } } if (IsTupleType) { builder = AddOrWrapTupleMembers(builder.ToImmutableAndFree()); Debug.Assert(builder is object); } return(builder.ToImmutableAndFree()); }
public sealed override ImmutableArray <Symbol> GetMembers() { var builder = ArrayBuilder <Symbol> .GetInstance(); if (_unbound) { // Preserve order of members. foreach (var t in OriginalDefinition.GetMembers()) { if (t.Kind == SymbolKind.NamedType) { builder.Add(((NamedTypeSymbol)t).AsMember(this)); } } } else { foreach (var t in OriginalDefinition.GetMembers()) { builder.Add(t.SymbolAsMember(this)); } } return(builder.ToImmutableAndFree()); }
private ImmutableArray <Symbol> GetMembersWorker(string name) { var originalMembers = OriginalDefinition.GetMembers(name); if (originalMembers.IsDefaultOrEmpty) { return(originalMembers); } var builder = ArrayBuilder <Symbol> .GetInstance(originalMembers.Length); foreach (var t in originalMembers) { builder.Add(t.SymbolAsMember(this)); } var substitutedMembers = builder.ToImmutableAndFree(); // cache of size 8 seems reasonable here. // considering that substituted methods have about 10 reference fields, // reusing just one may make the cache profitable. var cache = _lazyMembersByNameCache ?? (_lazyMembersByNameCache = new ConcurrentCache <string, ImmutableArray <Symbol> >(8)); cache.TryAdd(name, substitutedMembers); return(substitutedMembers); }
public override TypeSymbol GetTypeInferredDuringReduction(TypeParameterSymbol reducedFromTypeParameter) { // This will throw if API shouldn't be supported or there is a problem with the argument. var notUsed = OriginalDefinition.GetTypeInferredDuringReduction(reducedFromTypeParameter); Debug.Assert((object)notUsed == null && (object)OriginalDefinition.ReducedFrom != null); return(this.TypeArgumentsWithAnnotations[reducedFromTypeParameter.Ordinal].Type); }
internal override ImmutableArray <Symbol> GetEarlyAttributeDecodingMembers() { return(_unbound ? GetMembers() : OriginalDefinition .GetEarlyAttributeDecodingMembers() .SelectAsArray(s_symbolAsMemberFunc, this)); }
internal override NamedTypeSymbol FixedImplementationType(PEModuleBuilder emitModule) { // This occurs rarely, if ever. The scenario would be a generic struct // containing a fixed-size buffer. Given the rarity there would be little // benefit to "optimizing" the performance of this by caching the // translated implementation type. return((NamedTypeSymbol)_containingType.TypeSubstitution.SubstituteType(OriginalDefinition.FixedImplementationType(emitModule)).Type); }
public sealed override ImmutableArray <NamedTypeSymbol> GetTypeMembers( string name, int arity ) { return(OriginalDefinition .GetTypeMembers(name, arity) .SelectAsArray((t, self) => t.AsMember(self), this)); }
internal override TypeWithAnnotations GetFieldType(ConsList <FieldSymbol> fieldsBeingBound) { if (_lazyType == null) { var type = _containingType.TypeSubstitution.SubstituteType(OriginalDefinition.GetFieldType(fieldsBeingBound)); Interlocked.CompareExchange(ref _lazyType, new TypeWithAnnotations.Boxed(type), null); } return(_lazyType.Value); }
internal override ImmutableArray <Symbol> GetEarlyAttributeDecodingMembers(string name) { if (_unbound) { return(GetMembers(name)); } var builder = ArrayBuilder <Symbol> .GetInstance(); foreach (var t in OriginalDefinition.GetEarlyAttributeDecodingMembers(name)) { builder.Add(t.SymbolAsMember(this)); } return(builder.ToImmutableAndFree()); }
internal sealed override bool TryGetThisParameter(out ParameterSymbol thisParameter) { // Required in EE scenarios. Specifically, the EE binds in the context of a // substituted method, whereas the core compiler always binds within the // context of an original definition. // There should never be any reason to call this in normal compilation // scenarios, but the behavior should be sensible if it does occur. ParameterSymbol originalThisParameter; if (!OriginalDefinition.TryGetThisParameter(out originalThisParameter)) { thisParameter = null; return(false); } thisParameter = (object)originalThisParameter != null ? new ThisParameterSymbol(this) : null; return(true); }
/// <summary> /// Returns an unbound generic type of this named type. /// </summary> public NamedTypeSymbol ConstructUnboundGenericType() { return(OriginalDefinition.AsUnboundGenericType()); }
internal override TypeSymbol GetFieldType(ConsList <FieldSymbol> fieldsBeingBound) { if ((object)_lazyType == null) { Interlocked.CompareExchange(ref _lazyType, _containingType.TypeSubstitution.SubstituteTypeWithTupleUnification(OriginalDefinition.GetFieldType(fieldsBeingBound)).Type, null); } return(_lazyType); }
public override int GetHashCode() { return(Hash.Combine(_containingType, OriginalDefinition.GetHashCode())); }
internal sealed override bool CallsAreOmitted(SyntaxTree syntaxTree) { return(OriginalDefinition.CallsAreOmitted(syntaxTree)); }
internal sealed override NamedTypeSymbol GetDeclaredBaseType(ConsList <Symbol> basesBeingResolved) { return(_unbound ? null : Map.SubstituteNamedType(OriginalDefinition.GetDeclaredBaseType(basesBeingResolved))); }
internal sealed override ImmutableArray <NamedTypeSymbol> GetDeclaredInterfaces(ConsList <Symbol> basesBeingResolved) { return(_unbound ? ImmutableArray <NamedTypeSymbol> .Empty : Map.SubstituteNamedTypes(OriginalDefinition.GetDeclaredInterfaces(basesBeingResolved))); }
internal sealed override ImmutableArray <NamedTypeSymbol> InterfacesNoUseSiteDiagnostics(ConsList <Symbol> basesBeingResolved) { return(_unbound ? ImmutableArray <NamedTypeSymbol> .Empty : Map.SubstituteNamedTypes(OriginalDefinition.InterfacesNoUseSiteDiagnostics(basesBeingResolved))); }
public override ImmutableArray <CSharpAttributeData> GetAttributes() { return(OriginalDefinition.GetAttributes()); }
internal override TypeSymbolWithAnnotations GetFieldType(ConsList <FieldSymbol> fieldsBeingBound) { if (_lazyType.IsNull) { _lazyType.InterlockedInitialize(_containingType.TypeSubstitution.SubstituteTypeWithTupleUnification(OriginalDefinition.GetFieldType(fieldsBeingBound))); } return(_lazyType.ToType()); }
internal sealed override ImmutableArray <NamedTypeSymbol> GetTypeMembersUnordered() { return(OriginalDefinition.GetTypeMembersUnordered().SelectAsArray((t, self) => t.AsMember(self), this)); }
internal override bool GetUnificationUseSiteDiagnosticRecursive(ref DiagnosticInfo result, Symbol owner, ref HashSet <TypeSymbol> checkedTypes) => OriginalDefinition.GetUnificationUseSiteDiagnosticRecursive(ref result, owner, ref checkedTypes);