internal bool Equals(TypeParameterSymbol other) { return(Equals(other, TypeCompareKind.ConsiderEverything)); }
protected virtual TypeSymbolWithAnnotations SubstituteTypeParameter(TypeParameterSymbol typeParameter) { return(TypeSymbolWithAnnotations.Create(typeParameter)); }
internal AnonymousTypeTemplateSymbol(AnonymousTypeManager manager, AnonymousTypeDescriptor typeDescr) { this.Manager = manager; this.TypeDescriptorKey = typeDescr.Key; _smallestLocation = typeDescr.Location; // Will be set when the type's metadata is ready to be emitted, // <anonymous-type>.Name will throw exception if requested // before that moment. _nameAndIndex = null; int fieldsCount = typeDescr.Fields.Length; // members Symbol[] members = new Symbol[fieldsCount * 3 + 1]; int memberIndex = 0; // The array storing property symbols to be used in // generation of constructor and other methods if (fieldsCount > 0) { AnonymousTypePropertySymbol[] propertiesArray = new AnonymousTypePropertySymbol[fieldsCount]; TypeParameterSymbol[] typeParametersArray = new TypeParameterSymbol[fieldsCount]; // Process fields for (int fieldIndex = 0; fieldIndex < fieldsCount; fieldIndex++) { AnonymousTypeField field = typeDescr.Fields[fieldIndex]; // Add a type parameter AnonymousTypeParameterSymbol typeParameter = new AnonymousTypeParameterSymbol(this, fieldIndex, GeneratedNames.MakeAnonymousTypeParameterName(field.Name)); typeParametersArray[fieldIndex] = typeParameter; // Add a property AnonymousTypePropertySymbol property = new AnonymousTypePropertySymbol(this, field, TypeSymbolWithAnnotations.Create(typeParameter)); propertiesArray[fieldIndex] = property; // Property related symbols members[memberIndex++] = property; members[memberIndex++] = property.BackingField; members[memberIndex++] = property.GetMethod; } _typeParameters = typeParametersArray.AsImmutable(); this.Properties = propertiesArray.AsImmutable(); } else { _typeParameters = ImmutableArray <TypeParameterSymbol> .Empty; this.Properties = ImmutableArray <AnonymousTypePropertySymbol> .Empty; } // Add a constructor members[memberIndex++] = new AnonymousTypeConstructorSymbol(this, this.Properties); _members = members.AsImmutable(); Debug.Assert(memberIndex == _members.Length); // fill nameToSymbols map foreach (var symbol in _members) { _nameToSymbols.Add(symbol.Name, symbol); } // special members: Equals, GetHashCode, ToString MethodSymbol[] specialMembers = new MethodSymbol[3]; specialMembers[0] = new AnonymousTypeEqualsMethodSymbol(this); specialMembers[1] = new AnonymousTypeGetHashCodeMethodSymbol(this); specialMembers[2] = new AnonymousTypeToStringMethodSymbol(this); this.SpecialMembers = specialMembers.AsImmutable(); }
/// <summary> /// 3) T is an interface, class, struct, enum, or delegate type <![CDATA[S<A_1, ..., A_k>]]> constructed /// from a generic type <![CDATA[S<X_1, ..., X_k>]]> where for at least one A_i one /// of the following holds: /// a) X_i is covariant or invariant and A_i is output-unsafe [input-unsafe] /// b) X_i is contravariant or invariant and A_i is input-unsafe [output-unsafe] (note: spec has "input-safe", but it's a typo) /// </summary> /// <remarks> /// Slight rewrite to make it more idiomatic for C#: /// a) X_i is covariant and A_i is input-unsafe /// b) X_i is contravariant and A_i is output-unsafe /// c) X_i is invariant and A_i is input-unsafe or output-unsafe /// </remarks> private static bool IsVarianceUnsafe <T>( NamedTypeSymbol namedType, bool requireOutputSafety, bool requireInputSafety, Symbol context, LocationProvider <T> locationProvider, T locationArg, DiagnosticBag diagnostics) where T : Symbol { Debug.Assert(requireOutputSafety || requireInputSafety); switch (namedType.TypeKind) { case TypeKind.Class: case TypeKind.Struct: case TypeKind.Enum: // Can't be generic, but can be nested in generic. case TypeKind.Interface: case TypeKind.Delegate: case TypeKind.Error: break; default: return(false); } while ((object)namedType != null) { for (int i = 0; i < namedType.Arity; i++) { TypeParameterSymbol typeParam = namedType.TypeParameters[i]; TypeSymbol typeArg = namedType.TypeArgumentsNoUseSiteDiagnostics[i].TypeSymbol; bool requireOut; bool requireIn; switch (typeParam.Variance) { case VarianceKind.Out: // a) X_i is covariant and A_i is output-unsafe [input-unsafe] requireOut = requireOutputSafety; requireIn = requireInputSafety; break; case VarianceKind.In: // b) X_i is contravariant and A_i is input-unsafe [output-unsafe] requireOut = requireInputSafety; requireIn = requireOutputSafety; break; case VarianceKind.None: // c) X_i is invariant and A_i is output-unsafe or input-unsafe requireIn = true; requireOut = true; break; default: throw ExceptionUtilities.UnexpectedValue(typeParam.Variance); } if (IsVarianceUnsafe(typeArg, requireOut, requireIn, context, locationProvider, locationArg, diagnostics)) { return(true); } } namedType = namedType.ContainingType; } return(false); }
public SynthesizedSubstitutedTypeParameterSymbol(Symbol owner, TypeMap map, TypeParameterSymbol substitutedFrom, int ordinal) : base(owner, map, substitutedFrom, ordinal) { }
public WrappedTypeParameterSymbol(TypeParameterSymbol underlyingTypeParameter) { Debug.Assert((object)underlyingTypeParameter != null); _underlyingTypeParameter = underlyingTypeParameter; }
public ExtendedTypeParameterSymbol(TypeParameterSymbol underlyingTypeParameter, TypeAccessModifiers modifiers) : base(underlyingTypeParameter) { AccessModifiers = modifiers; }
/// <summary> /// If this method is a reduced extension method, returns a type inferred during reduction process for the type parameter. /// </summary> /// <param name="reducedFromTypeParameter">Type parameter of the corresponding <see cref="ReducedFrom"/> method.</param> /// <returns>Inferred type or Nothing if nothing was inferred.</returns> /// <exception cref="System.InvalidOperationException">If this is not a reduced extension method.</exception> /// <exception cref="System.ArgumentNullException">If <paramref name="reducedFromTypeParameter"/> is null.</exception> /// <exception cref="System.ArgumentException">If <paramref name="reducedFromTypeParameter"/> doesn't belong to the corresponding <see cref="ReducedFrom"/> method.</exception> public virtual TypeSymbol GetTypeInferredDuringReduction(TypeParameterSymbol reducedFromTypeParameter) { throw new InvalidOperationException(); }