public EmbeddedTypeParameter( EmbeddedMethod containingMethod, TypeParameterSymbolAdapter underlyingTypeParameter ) : base(containingMethod, underlyingTypeParameter) { Debug.Assert(underlyingTypeParameter.AdaptedTypeParameterSymbol.IsDefinition); }
public RetargetingTypeParameterSymbol(RetargetingModuleSymbol retargetingModule, TypeParameterSymbol underlyingTypeParameter) : base(underlyingTypeParameter) { Debug.Assert((object)retargetingModule != null); Debug.Assert(!(underlyingTypeParameter is RetargetingTypeParameterSymbol)); _retargetingModule = retargetingModule; }
public static bool DependsOn(this TypeParameterSymbol typeParameter1, TypeParameterSymbol typeParameter2) { Debug.Assert((object)typeParameter1 != null); Debug.Assert((object)typeParameter2 != null); Func<TypeParameterSymbol, IEnumerable<TypeParameterSymbol>> dependencies = x => x.ConstraintTypesNoUseSiteDiagnostics.OfType<TypeParameterSymbol>(); return dependencies.TransitiveClosure(typeParameter1).Contains(typeParameter2); }
internal SubstitutedTypeParameterSymbol(Symbol newContainer, TypeMap map, TypeParameterSymbol substitutedFrom) { _container = newContainer; // it is important that we don't use the map here in the constructor, as the map is still being filled // in by TypeMap.WithAlphaRename. Instead, we can use the map lazily when yielding the constraints. _map = map; _substitutedFrom = substitutedFrom; }
public RetargetingTypeParameterSymbol(RetargetingModuleSymbol retargetingModule, TypeParameterSymbol underlyingTypeParameter) { Debug.Assert((object)retargetingModule != null); Debug.Assert((object)underlyingTypeParameter != null); Debug.Assert(!(underlyingTypeParameter is RetargetingTypeParameterSymbol)); this.retargetingModule = retargetingModule; this.underlyingTypeParameter = underlyingTypeParameter; }
protected sealed override TypeWithModifiers SubstituteTypeParameter(TypeParameterSymbol typeParameter) { // It might need to be substituted directly. TypeWithModifiers result; if (Mapping.TryGetValue(typeParameter, out result)) { return result; } return new TypeWithModifiers(typeParameter); }
protected sealed override TypeSymbol SubstituteTypeParameter(TypeParameterSymbol typeParameter) { // It might need to be substituted directly. TypeSymbol result; if (Mapping.TryGetValue(typeParameter, out result)) { return result; } return typeParameter; }
public EETypeParameterSymbol( Symbol container, TypeParameterSymbol sourceTypeParameter, int ordinal, Func<TypeMap> getTypeMap) { Debug.Assert((container.Kind == SymbolKind.NamedType) || (container.Kind == SymbolKind.Method)); _container = container; _sourceTypeParameter = sourceTypeParameter; _ordinal = ordinal; _getTypeMap = getTypeMap; }
internal SubstitutedTypeParameterSymbol(Symbol newContainer, TypeMap map, TypeParameterSymbol substitutedFrom, int ordinal) { _container = newContainer; // it is important that we don't use the map here in the constructor, as the map is still being filled // in by TypeMap.WithAlphaRename. Instead, we can use the map lazily when yielding the constraints. _map = map; _substitutedFrom = substitutedFrom; _ordinal = ordinal; #if DEBUG_ALPHA _mySequence = _nextSequence++; #endif }
protected sealed override TypeWithModifiers SubstituteTypeParameter(TypeParameterSymbol typeParameter) { // It might need to be substituted directly. TypeWithModifiers result; if (Mapping.TryGetValue(typeParameter, out result)) { if (typeParameter.NullabilityPreservation == CodeAnalysis.Symbols.NullabilityPreservationKind.None && result.Type.Kind == SymbolKind.NonNullableReference) { return new TypeWithModifiers(((NonNullableReferenceTypeSymbol)result.Type).UnderlyingType); } return result; } return new TypeWithModifiers(typeParameter); }
/// <summary> /// Used for <see cref="SynthesizedDelegateSymbol"/> construction. /// </summary> protected SynthesizedContainer(NamespaceOrTypeSymbol containingSymbol, string name, int parameterCount, bool returnsVoid) { var typeParameters = new TypeParameterSymbol[parameterCount + (returnsVoid ? 0 : 1)]; for (int i = 0; i < parameterCount; i++) { typeParameters[i] = new AnonymousTypeManager.AnonymousTypeParameterSymbol(this, i, "T" + (i + 1)); } if (!returnsVoid) { typeParameters[parameterCount] = new AnonymousTypeManager.AnonymousTypeParameterSymbol(this, parameterCount, "TResult"); } this.containingSymbol = containingSymbol; this.name = name; this.TypeMap = TypeMap.Empty; this.typeParameters = typeParameters.AsImmutableOrNull(); }
private static void GrowPool(int count) { var initialPool = s_parameterPool; while (count > initialPool.Length) { var newPoolSize = ((count + 0x0F) & ~0xF); // grow in increments of 16 var newPool = new TypeParameterSymbol[newPoolSize]; Array.Copy(initialPool, newPool, initialPool.Length); for (int i = initialPool.Length; i < newPool.Length; i++) { newPool[i] = new IndexedTypeParameterSymbol(i); } Interlocked.CompareExchange(ref s_parameterPool, newPool, initialPool); // repeat if race condition occurred and someone else resized the pool before us // and the new pool is still too small initialPool = s_parameterPool; } }
//////////////////////////////////////////////////////////////////////////////// // // Input types // private static bool DoesInputTypeContain(BoundExpression argument, TypeSymbol formalParameterType, TypeParameterSymbol typeParameter) { // SPEC: If E is a method group or an anonymous function and T is a delegate // SPEC: type or expression tree type then all the parameter types of T are // SPEC: input types of E with type T. var delegateType = formalParameterType.GetDelegateType(); if ((object)delegateType == null) { return false; // No input types. } if (argument.Kind != BoundKind.UnboundLambda && argument.Kind != BoundKind.MethodGroup) { return false; // No input types. } var delegateParameters = delegateType.DelegateParameters(); if (delegateParameters.IsDefaultOrEmpty) { return false; } foreach (var delegateParameter in delegateParameters) { if (delegateParameter.Type.ContainsTypeParameter(typeParameter)) { return true; } } return false; }
internal override void GenerateMethodBody(TypeCompilationState compilationState, DiagnosticBag diagnostics) { AnonymousTypeManager manager = ((AnonymousTypeTemplateSymbol)this.ContainingType).Manager; SyntheticBoundNodeFactory F = this.CreateBoundNodeFactory(compilationState, diagnostics); // Method body: // // { // $anonymous$ local = value as $anonymous$; // return local != null // && System.Collections.Generic.EqualityComparer<T_1>.Default.Equals(this.backingFld_1, local.backingFld_1) // ... // && System.Collections.Generic.EqualityComparer<T_N>.Default.Equals(this.backingFld_N, local.backingFld_N); // } // Type and type expression AnonymousTypeTemplateSymbol anonymousType = (AnonymousTypeTemplateSymbol)this.ContainingType; // local BoundAssignmentOperator assignmentToTemp; BoundLocal boundLocal = F.StoreToTemp(F.As(F.Parameter(this.parameters[0]), anonymousType), out assignmentToTemp); // Generate: statement <= 'local = value as $anonymous$' BoundStatement assignment = F.ExpressionStatement(assignmentToTemp); // Generate expression for return statement // retExpression <= 'local != null' BoundExpression retExpression = F.Binary(BinaryOperatorKind.ObjectNotEqual, manager.System_Boolean, F.Convert(manager.System_Object, boundLocal), F.Null(manager.System_Object)); // prepare symbols MethodSymbol equalityComparer_Equals = manager.System_Collections_Generic_EqualityComparer_T__Equals; MethodSymbol equalityComparer_get_Default = manager.System_Collections_Generic_EqualityComparer_T__get_Default; NamedTypeSymbol equalityComparerType = equalityComparer_Equals.ContainingType; // Compare fields for (int index = 0; index < anonymousType.Properties.Length; index++) { // Prepare constructed symbols TypeParameterSymbol typeParameter = anonymousType.TypeParameters[index]; FieldSymbol fieldSymbol = anonymousType.Properties[index].BackingField; NamedTypeSymbol constructedEqualityComparer = equalityComparerType.Construct(typeParameter); // Generate 'retExpression' = 'retExpression && System.Collections.Generic.EqualityComparer<T_index>. // Default.Equals(this.backingFld_index, local.backingFld_index)' retExpression = F.LogicalAnd(retExpression, F.Call(F.StaticCall(constructedEqualityComparer, equalityComparer_get_Default.AsMember(constructedEqualityComparer)), equalityComparer_Equals.AsMember(constructedEqualityComparer), F.Field(F.This(), fieldSymbol), F.Field(boundLocal, fieldSymbol))); } // Final return statement BoundStatement retStatement = F.Return(retExpression); // Create a bound block F.CloseMethod(F.Block(ImmutableArray.Create <LocalSymbol>(boundLocal.LocalSymbol), assignment, retStatement)); }
protected virtual TypeWithModifiers SubstituteTypeParameter(TypeParameterSymbol typeParameter) { return new TypeWithModifiers(typeParameter); }
// See TypeBind::CheckSingleConstraint. private static bool CheckConstraints( Symbol containingSymbol, ConversionsBase conversions, TypeMap substitution, TypeParameterSymbol typeParameter, TypeSymbol typeArgument, Compilation currentCompilation, ArrayBuilder<TypeParameterDiagnosticInfo> diagnosticsBuilder, ref ArrayBuilder<TypeParameterDiagnosticInfo> useSiteDiagnosticsBuilder, HashSet<TypeParameterSymbol> ignoreTypeConstraintsDependentOnTypeParametersOpt) { Debug.Assert(substitution != null); // The type parameters must be original definitions of type parameters from the containing symbol. Debug.Assert(ReferenceEquals(typeParameter.ContainingSymbol, containingSymbol.OriginalDefinition)); if (typeArgument.IsErrorType()) { return true; } if (typeArgument.IsPointerType() || typeArgument.IsRestrictedType() || typeArgument.SpecialType == SpecialType.System_Void) { // "The type '{0}' may not be used as a type argument" diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new CSDiagnosticInfo(ErrorCode.ERR_BadTypeArgument, typeArgument))); return false; } if (typeArgument.IsStatic) { // "'{0}': static types cannot be used as type arguments" diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new CSDiagnosticInfo(ErrorCode.ERR_GenericArgIsStaticClass, typeArgument))); return false; } if (typeParameter.HasReferenceTypeConstraint && !typeArgument.IsReferenceType) { // "The type '{2}' must be a reference type in order to use it as parameter '{1}' in the generic type or method '{0}'" diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new CSDiagnosticInfo(ErrorCode.ERR_RefConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument))); return false; } if (typeParameter.HasValueTypeConstraint && !typeArgument.IsNonNullableValueType()) { // "The type '{2}' must be a non-nullable value type in order to use it as parameter '{1}' in the generic type or method '{0}'" diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new CSDiagnosticInfo(ErrorCode.ERR_ValConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument))); return false; } // The type parameters for a constructed type/method are the type parameters of // the ConstructedFrom type/method, so the constraint types are not substituted. // For instance with "class C<T, U> where T : U", the type parameter for T in "C<object, int>" // has constraint "U", not "int". We need to substitute the constraints from the // original definition of the type parameters using the map from the constructed symbol. var constraintTypes = ArrayBuilder<TypeSymbol>.GetInstance(); HashSet<DiagnosticInfo> useSiteDiagnostics = null; substitution.SubstituteTypesDistinctWithoutModifiers(typeParameter.ConstraintTypesWithDefinitionUseSiteDiagnostics(ref useSiteDiagnostics), constraintTypes, ignoreTypeConstraintsDependentOnTypeParametersOpt); bool hasError = false; foreach (var constraintType in constraintTypes) { if (SatisfiesConstraintType(conversions, typeArgument, constraintType, ref useSiteDiagnostics)) { continue; } ErrorCode errorCode; if (typeArgument.IsReferenceType) { errorCode = ErrorCode.ERR_GenericConstraintNotSatisfiedRefType; } else if (typeArgument.IsNullableType()) { errorCode = constraintType.IsInterfaceType() ? ErrorCode.ERR_GenericConstraintNotSatisfiedNullableInterface : ErrorCode.ERR_GenericConstraintNotSatisfiedNullableEnum; } else if (typeArgument.TypeKind == TypeKind.TypeParameter) { errorCode = ErrorCode.ERR_GenericConstraintNotSatisfiedTyVar; } else { errorCode = ErrorCode.ERR_GenericConstraintNotSatisfiedValType; } SymbolDistinguisher distinguisher = new SymbolDistinguisher(currentCompilation, constraintType, typeArgument); diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new CSDiagnosticInfo(errorCode, containingSymbol.ConstructedFrom(), distinguisher.First, typeParameter, distinguisher.Second))); hasError = true; } if (AppendUseSiteDiagnostics(useSiteDiagnostics, typeParameter, ref useSiteDiagnosticsBuilder)) { hasError = true; } constraintTypes.Free(); // Check the constructor constraint. if (typeParameter.HasConstructorConstraint && !SatisfiesConstructorConstraint(typeArgument)) { // "'{2}' must be a non-abstract type with a public parameterless constructor in order to use it as parameter '{1}' in the generic type or method '{0}'" diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new CSDiagnosticInfo(ErrorCode.ERR_NewConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument))); return false; } return !hasError; }
private static void AddSubstitution(ref MutableTypeMap substitution, TypeParameterSymbol tp1, TypeWithModifiers t2) { if (substitution == null) { substitution = new MutableTypeMap(); } // MutableTypeMap.Add will throw if the key has already been added. However, // if t1 was already in the substitution, it would have been substituted at the // start of CanUnifyHelper and we wouldn't be here. substitution.Add(tp1, t2); }
internal void Add(TypeParameterSymbol key, TypeSymbol value) { this.Mapping.Add(key, value); }
public override TypeSymbol GetTypeInferredDuringReduction(TypeParameterSymbol reducedFromTypeParameter) { if ((object)reducedFromTypeParameter == null) { throw new System.ArgumentNullException(); } if (reducedFromTypeParameter.ContainingSymbol != this.reducedFrom) { throw new System.ArgumentException(); } return null; }
internal void Add(TypeParameterSymbol key, TypeWithModifiers value) { this.Mapping.Add(key, value); }
protected virtual TypeSymbolWithAnnotations SubstituteTypeParameter(TypeParameterSymbol typeParameter) { return(TypeSymbolWithAnnotations.Create(typeParameter)); }
protected virtual TypeWithModifiers SubstituteTypeParameter(TypeParameterSymbol typeParameter) { return(new TypeWithModifiers(typeParameter)); }
/// <summary> /// (null TypeParameterSymbol "parameter"): Checks if the given type is a type parameter /// or its referent type is a type parameter (array/pointer) or contains a type parameter (aggregate type) /// (non-null TypeParameterSymbol "parameter"): above + also checks if the type parameter /// is the same as "parameter" /// </summary> public static bool ContainsTypeParameter(this TypeSymbol type, TypeParameterSymbol parameter = null) { var result = type.VisitType(ContainsTypeParameterPredicate, parameter); return((object)result != null); }
public static bool IsMethodTypeParameter(this TypeParameterSymbol p) { return(p.ContainingSymbol.Kind == SymbolKind.Method); }
private static void AddVarianceError <T>( this BindingDiagnosticBag diagnostics, TypeParameterSymbol unsafeTypeParameter, Symbol context, LocationProvider <T> locationProvider, T locationArg, MessageID expectedVariance ) where T : Symbol { MessageID actualVariance; switch (unsafeTypeParameter.Variance) { case VarianceKind.In: actualVariance = MessageID.IDS_Contravariant; break; case VarianceKind.Out: actualVariance = MessageID.IDS_Covariant; break; default: throw ExceptionUtilities.UnexpectedValue(unsafeTypeParameter.Variance); } // Get a location that roughly represents the unsafe type parameter use. // (Typically, the locationProvider will return the location of the entire type // reference rather than the specific type parameter, for instance, returning // "C<T>[]" for "interface I<in T> { C<T>[] F(); }" rather than the type parameter // in "C<T>[]", but that is better than returning the location of T within "I<in T>". var location = locationProvider(locationArg) ?? unsafeTypeParameter.Locations[0]; // CONSIDER: instead of using the same error code for all variance errors, we could use different codes for "requires input-safe", // "requires output-safe", and "requires input-safe and output-safe". This would make the error codes much easier to document and // much more actionable. // UNDONE: related location for use is much more useful if (!(context is TypeSymbol) && context.IsStatic) { diagnostics.Add( ErrorCode.ERR_UnexpectedVarianceStaticMember, location, context, unsafeTypeParameter, actualVariance.Localize(), expectedVariance.Localize(), new CSharpRequiredLanguageVersion( MessageID.IDS_FeatureVarianceSafetyForStaticInterfaceMembers.RequiredVersion() ) ); } else { diagnostics.Add( ErrorCode.ERR_UnexpectedVariance, location, context, unsafeTypeParameter, actualVariance.Localize(), expectedVariance.Localize() ); } }
public static bool HaveSameConstraints(TypeParameterSymbol typeParameter1, TypeMap typeMap1, TypeParameterSymbol typeParameter2, TypeMap typeMap2) { // Spec 13.4.3: Implementation of generic methods. if ((typeParameter1.HasConstructorConstraint != typeParameter2.HasConstructorConstraint) || (typeParameter1.HasReferenceTypeConstraint != typeParameter2.HasReferenceTypeConstraint) || (typeParameter1.HasValueTypeConstraint != typeParameter2.HasValueTypeConstraint) || (typeParameter1.HasUnmanagedTypeConstraint != typeParameter2.HasUnmanagedTypeConstraint) || (typeParameter1.Variance != typeParameter2.Variance)) { return(false); } return(HaveSameTypeConstraints(typeParameter1, typeMap1, typeParameter2, typeMap2, TypeSymbol.EqualsIgnoringDynamicTupleNamesAndNullabilityComparer)); }
private IEnumerable<ISymbol> LookupTypeParameterMembers(string types, string constraints, string memberName, out TypeParameterSymbol typeParameter) { var template = @" {0} public class C<T> where T : {1} {{ void M() {{ System.Console.WriteLine(/*<bind>*/default(T)/*</bind>*/); }} }} "; var tree = Parse(string.Format(template, types, constraints)); var comp = CreateCompilationWithMscorlibAndSystemCore(new[] { tree }); comp.VerifyDiagnostics(); var model = comp.GetSemanticModel(tree); var classC = comp.GlobalNamespace.GetMember<NamedTypeSymbol>("C"); typeParameter = classC.TypeParameters.Single(); var exprSyntaxToBind = GetExprSyntaxForBinding(GetExprSyntaxList(tree)); Assert.Equal(SyntaxKind.DefaultExpression, exprSyntaxToBind.Kind()); return model.LookupSymbols(exprSyntaxToBind.SpanStart, typeParameter, memberName); }
private static bool HaveSameTypeConstraints(TypeParameterSymbol typeParameter1, TypeMap typeMap1, TypeParameterSymbol typeParameter2, TypeMap typeMap2, EqualityComparer <TypeSymbol> comparer) { // Check that constraintTypes1 is a subset of constraintTypes2 and // also that constraintTypes2 is a subset of constraintTypes1 // (see SymbolPreparer::CheckImplicitImplConstraints). var constraintTypes1 = typeParameter1.ConstraintTypesNoUseSiteDiagnostics; var constraintTypes2 = typeParameter2.ConstraintTypesNoUseSiteDiagnostics; // The two sets of constraints may differ in size but still be considered // the same (duplicated constraints, ignored "object" constraints), but // if both are zero size, the sets must be equal. if ((constraintTypes1.Length == 0) && (constraintTypes2.Length == 0)) { return(true); } var substitutedTypes1 = new HashSet <TypeSymbol>(comparer); var substitutedTypes2 = new HashSet <TypeSymbol>(comparer); SubstituteConstraintTypes(constraintTypes1, typeMap1, substitutedTypes1); SubstituteConstraintTypes(constraintTypes2, typeMap2, substitutedTypes2); return(AreConstraintTypesSubset(substitutedTypes1, substitutedTypes2, typeParameter2) && AreConstraintTypesSubset(substitutedTypes2, substitutedTypes1, typeParameter1)); }
public TypeParameterDiagnosticInfo(TypeParameterSymbol typeParameter, DiagnosticInfo diagnosticInfo) { this.TypeParameter = typeParameter; this.DiagnosticInfo = diagnosticInfo; }
public static bool HaveSameNullabilityInConstraints(TypeParameterSymbol typeParameter1, TypeMap typeMap1, TypeParameterSymbol typeParameter2, TypeMap typeMap2) { if (!typeParameter1.IsValueType) { bool?isNotNullable1 = typeParameter1.IsNotNullable; bool?isNotNullable2 = typeParameter2.IsNotNullable; if (isNotNullable1.HasValue && isNotNullable2.HasValue && isNotNullable1.GetValueOrDefault() != isNotNullable2.GetValueOrDefault()) { return(false); } } return(HaveSameTypeConstraints(typeParameter1, typeMap1, typeParameter2, typeMap2, TypeSymbol.EqualsAllIgnoreOptionsPlusNullableWithUnknownMatchesAnyComparer)); }
private static bool IsValueType(TypeParameterSymbol typeParameter, ImmutableArray<TypeSymbol> constraintTypes) { return typeParameter.HasValueTypeConstraint || TypeParameterSymbol.IsValueTypeFromConstraintTypes(constraintTypes); }
internal bool Equals(TypeParameterSymbol other) { return(Equals(other, TypeCompareKind.ConsiderEverything)); }
public virtual void VisitTypeParameter(TypeParameterSymbol symbol) { DefaultVisit(symbol); }
public ImmutableArray <CustomModifier> GetTypeArgumentsCustomModifiersFor(TypeParameterSymbol originalDefinition) { Debug.Assert((object)originalDefinition != null); Debug.Assert(originalDefinition.IsDefinition); return(SubstituteTypeParameter(originalDefinition).CustomModifiers); }
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, 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(); }
// See TypeBind::CheckSingleConstraint. private static bool CheckConstraints( Symbol containingSymbol, ConversionsBase conversions, TypeMap substitution, TypeParameterSymbol typeParameter, TypeSymbol typeArgument, Compilation currentCompilation, ArrayBuilder <TypeParameterDiagnosticInfo> diagnosticsBuilder, ref ArrayBuilder <TypeParameterDiagnosticInfo> useSiteDiagnosticsBuilder) { Debug.Assert(substitution != null); // The type parameters must be original definitions of type parameters from the containing symbol. Debug.Assert(ReferenceEquals(typeParameter.ContainingSymbol, containingSymbol.OriginalDefinition)); if (typeArgument.IsErrorType()) { return(true); } if (typeArgument.IsPointerType() || typeArgument.IsRestrictedType() || typeArgument.SpecialType == SpecialType.System_Void) { // "The type '{0}' may not be used as a type argument" diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new CSDiagnosticInfo(ErrorCode.ERR_BadTypeArgument, typeArgument))); return(false); } if (typeArgument.IsStatic) { // "'{0}': static types cannot be used as type arguments" diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new CSDiagnosticInfo(ErrorCode.ERR_GenericArgIsStaticClass, typeArgument))); return(false); } if (typeParameter.HasReferenceTypeConstraint && !typeArgument.IsReferenceType) { // "The type '{2}' must be a reference type in order to use it as parameter '{1}' in the generic type or method '{0}'" diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new CSDiagnosticInfo(ErrorCode.ERR_RefConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument))); return(false); } if (typeParameter.HasValueTypeConstraint && !typeArgument.IsNonNullableValueType()) { // "The type '{2}' must be a non-nullable value type in order to use it as parameter '{1}' in the generic type or method '{0}'" diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new CSDiagnosticInfo(ErrorCode.ERR_ValConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument))); return(false); } // The type parameters for a constructed type/method are the type parameters of // the ConstructedFrom type/method, so the constraint types are not substituted. // For instance with "class C<T, U> where T : U", the type parameter for T in "C<object, int>" // has constraint "U", not "int". We need to substitute the constraints from the // original definition of the type parameters using the map from the constructed symbol. var constraintTypes = ArrayBuilder <TypeSymbol> .GetInstance(); HashSet <DiagnosticInfo> useSiteDiagnostics = null; substitution.SubstituteTypesDistinctWithoutModifiers(typeParameter.ConstraintTypesWithDefinitionUseSiteDiagnostics(ref useSiteDiagnostics), constraintTypes); bool hasError = false; foreach (var constraintType in constraintTypes) { if (SatisfiesConstraintType(conversions, typeArgument, constraintType, ref useSiteDiagnostics)) { continue; } ErrorCode errorCode; if (typeArgument.IsReferenceType) { errorCode = ErrorCode.ERR_GenericConstraintNotSatisfiedRefType; } else if (typeArgument.IsNullableType()) { errorCode = constraintType.IsInterfaceType() ? ErrorCode.ERR_GenericConstraintNotSatisfiedNullableInterface : ErrorCode.ERR_GenericConstraintNotSatisfiedNullableEnum; } else if (typeArgument.TypeKind == TypeKind.TypeParameter) { errorCode = ErrorCode.ERR_GenericConstraintNotSatisfiedTyVar; } else { errorCode = ErrorCode.ERR_GenericConstraintNotSatisfiedValType; } SymbolDistinguisher distinguisher = new SymbolDistinguisher(currentCompilation, constraintType, typeArgument); diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new CSDiagnosticInfo(errorCode, containingSymbol.ConstructedFrom(), distinguisher.First, typeParameter, distinguisher.Second))); hasError = true; } if (AppendUseSiteDiagnostics(useSiteDiagnostics, typeParameter, ref useSiteDiagnosticsBuilder)) { hasError = true; } constraintTypes.Free(); // Check the constructor constraint. if (typeParameter.HasConstructorConstraint && !SatisfiesConstructorConstraint(typeArgument)) { // "'{2}' must be a non-abstract type with a public parameterless constructor in order to use it as parameter '{1}' in the generic type or method '{0}'" diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new CSDiagnosticInfo(ErrorCode.ERR_NewConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument))); return(false); } return(!hasError); }
internal bool Equals(TypeParameterSymbol other) { return(Equals(other, false, false)); }
private static bool IsValueType(TypeParameterSymbol typeParameter, ImmutableArray <TypeSymbol> constraintTypes) { return(typeParameter.HasValueTypeConstraint || TypeParameterSymbol.IsValueTypeFromConstraintTypes(constraintTypes)); }
private void AddExactBound(TypeParameterSymbol methodTypeParameter, TypeSymbol exactBound) { Debug.Assert(IsUnfixedTypeParameter(methodTypeParameter)); int methodTypeParameterIndex = methodTypeParameter.Ordinal; if (_exactBounds[methodTypeParameterIndex] == null) { _exactBounds[methodTypeParameterIndex] = new HashSet<TypeSymbol>(); } _exactBounds[methodTypeParameterIndex].Add(exactBound); }
private static TypeParameterDiagnosticInfo GenerateConflictingConstraintsError(TypeParameterSymbol typeParameter, TypeSymbol deducedBase, bool classConflict) { // "Type parameter '{0}' inherits conflicting constraints '{1}' and '{2}'" return(new TypeParameterDiagnosticInfo(typeParameter, new CSDiagnosticInfo(ErrorCode.ERR_BaseConstraintConflict, typeParameter, deducedBase, classConflict ? "class" : "struct"))); }
//////////////////////////////////////////////////////////////////////////////// // // Output types // private static bool DoesOutputTypeContain(BoundExpression argument, TypeSymbol formalParameterType, TypeParameterSymbol typeParameter) { // SPEC: If E is a method group or an anonymous function and T is a delegate // SPEC: type or expression tree type then the return type of T is an output type // SPEC: of E with type T. var delegateType = formalParameterType.GetDelegateType(); if ((object)delegateType == null) { return false; } if (argument.Kind != BoundKind.UnboundLambda && argument.Kind != BoundKind.MethodGroup) { return false; } MethodSymbol delegateInvoke = delegateType.DelegateInvokeMethod; if ((object)delegateInvoke == null || delegateInvoke.HasUseSiteError) { return false; } var delegateReturnType = delegateInvoke.ReturnType; if ((object)delegateReturnType == null) { return false; } return delegateReturnType.ContainsTypeParameter(typeParameter); }
// Based on SymbolLoader::ResolveBounds. public static TypeParameterBounds ResolveBounds( this TypeParameterSymbol typeParameter, AssemblySymbol corLibrary, ConsList <TypeParameterSymbol> inProgress, ImmutableArray <TypeSymbol> constraintTypes, bool inherited, CSharpCompilation currentCompilation, ArrayBuilder <TypeParameterDiagnosticInfo> diagnosticsBuilder, ref ArrayBuilder <TypeParameterDiagnosticInfo> useSiteDiagnosticsBuilder) { Debug.Assert(currentCompilation == null || typeParameter.IsFromCompilation(currentCompilation)); ImmutableArray <NamedTypeSymbol> interfaces; NamedTypeSymbol effectiveBaseClass = corLibrary.GetSpecialType(typeParameter.HasValueTypeConstraint ? SpecialType.System_ValueType : SpecialType.System_Object); TypeSymbol deducedBaseType = effectiveBaseClass; DynamicTypeEraser dynamicEraser = null; if (constraintTypes.Length == 0) { interfaces = ImmutableArray <NamedTypeSymbol> .Empty; } else { var constraintTypesBuilder = ArrayBuilder <TypeSymbol> .GetInstance(); var interfacesBuilder = ArrayBuilder <NamedTypeSymbol> .GetInstance(); var conversions = new TypeConversions(corLibrary); HashSet <DiagnosticInfo> useSiteDiagnostics = null; // Resolve base types, determine the effective base class and // interfaces, and filter out any constraint types that cause cycles. foreach (var constraintType in constraintTypes) { NamedTypeSymbol constraintEffectiveBase; TypeSymbol constraintDeducedBase; switch (constraintType.TypeKind) { case TypeKind.Dynamic: Debug.Assert(inherited || currentCompilation == null); continue; case TypeKind.TypeParameter: { var containingSymbol = typeParameter.ContainingSymbol; var constraintTypeParameter = (TypeParameterSymbol)constraintType; ConsList <TypeParameterSymbol> constraintsInProgress; if (constraintTypeParameter.ContainingSymbol == containingSymbol) { // The constraint type parameter is from the same containing type or method. if (inProgress.ContainsReference(constraintTypeParameter)) { // "Circular constraint dependency involving '{0}' and '{1}'" diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(constraintTypeParameter, new CSDiagnosticInfo(ErrorCode.ERR_CircularConstraint, constraintTypeParameter, typeParameter))); continue; } constraintsInProgress = inProgress; } else { // The constraint type parameter is from a different containing symbol so no cycle. constraintsInProgress = ConsList <TypeParameterSymbol> .Empty; } // Use the calculated bounds from the constraint type parameter. constraintEffectiveBase = constraintTypeParameter.GetEffectiveBaseClass(constraintsInProgress); constraintDeducedBase = constraintTypeParameter.GetDeducedBaseType(constraintsInProgress); AddInterfaces(interfacesBuilder, constraintTypeParameter.GetInterfaces(constraintsInProgress)); if (constraintTypeParameter.HasValueTypeConstraint && !inherited && currentCompilation != null && constraintTypeParameter.IsFromCompilation(currentCompilation)) { // "Type parameter '{1}' has the 'struct' constraint so '{1}' cannot be used as a constraint for '{0}'" diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new CSDiagnosticInfo(ErrorCode.ERR_ConWithValCon, typeParameter, constraintTypeParameter))); continue; } } break; case TypeKind.Interface: case TypeKind.Class: case TypeKind.Delegate: NamedTypeSymbol erasedConstraintType; if (inherited || currentCompilation == null) { // only inherited constraints may contain dynamic if (dynamicEraser == null) { dynamicEraser = new DynamicTypeEraser(corLibrary.GetSpecialType(SpecialType.System_Object)); } erasedConstraintType = (NamedTypeSymbol)dynamicEraser.EraseDynamic(constraintType); } else { Debug.Assert(!constraintType.ContainsDynamic()); Debug.Assert(constraintType.TypeKind != TypeKind.Delegate); erasedConstraintType = (NamedTypeSymbol)constraintType; } if (constraintType.IsInterfaceType()) { AddInterface(interfacesBuilder, erasedConstraintType); constraintTypesBuilder.Add(constraintType); continue; } else { constraintEffectiveBase = erasedConstraintType; constraintDeducedBase = constraintType; break; } case TypeKind.Struct: Debug.Assert(inherited || currentCompilation == null); constraintEffectiveBase = corLibrary.GetSpecialType(SpecialType.System_ValueType); constraintDeducedBase = constraintType; break; case TypeKind.Enum: Debug.Assert(inherited || currentCompilation == null); constraintEffectiveBase = corLibrary.GetSpecialType(SpecialType.System_Enum); constraintDeducedBase = constraintType; break; case TypeKind.Array: Debug.Assert(inherited || currentCompilation == null); constraintEffectiveBase = corLibrary.GetSpecialType(SpecialType.System_Array); constraintDeducedBase = constraintType; break; case TypeKind.Error: constraintEffectiveBase = (NamedTypeSymbol)constraintType; constraintDeducedBase = constraintType; break; case TypeKind.Submission: default: throw ExceptionUtilities.UnexpectedValue(constraintType.TypeKind); } CheckEffectiveAndDeducedBaseTypes(conversions, constraintEffectiveBase, constraintDeducedBase); constraintTypesBuilder.Add(constraintType); // Determine the more encompassed of the current effective base // class and the previously computed effective base class. if (!deducedBaseType.IsErrorType() && !constraintDeducedBase.IsErrorType()) { if (!IsEncompassedBy(conversions, deducedBaseType, constraintDeducedBase, ref useSiteDiagnostics)) { if (!IsEncompassedBy(conversions, constraintDeducedBase, deducedBaseType, ref useSiteDiagnostics)) { // "Type parameter '{0}' inherits conflicting constraints '{1}' and '{2}'" diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new CSDiagnosticInfo(ErrorCode.ERR_BaseConstraintConflict, typeParameter, constraintDeducedBase, deducedBaseType))); } else { deducedBaseType = constraintDeducedBase; effectiveBaseClass = constraintEffectiveBase; } } } } AppendUseSiteDiagnostics(useSiteDiagnostics, typeParameter, ref useSiteDiagnosticsBuilder); CheckEffectiveAndDeducedBaseTypes(conversions, effectiveBaseClass, deducedBaseType); constraintTypes = constraintTypesBuilder.ToImmutableAndFree(); interfaces = interfacesBuilder.ToImmutableAndFree(); } Debug.Assert((effectiveBaseClass.SpecialType == SpecialType.System_Object) || (deducedBaseType.SpecialType != SpecialType.System_Object)); // Only create a TypeParameterBounds instance for this type // parameter if the bounds are not the default values. if ((constraintTypes.Length == 0) && (deducedBaseType.SpecialType == SpecialType.System_Object)) { Debug.Assert(effectiveBaseClass.SpecialType == SpecialType.System_Object); Debug.Assert(interfaces.Length == 0); return(null); } var bounds = new TypeParameterBounds(constraintTypes, interfaces, effectiveBaseClass, deducedBaseType); // Additional constraint checks for overrides. if (inherited) { CheckOverrideConstraints(typeParameter, bounds, diagnosticsBuilder); } return(bounds); }
public EmbeddedTypeParameter(EmbeddedMethod containingMethod, TypeParameterSymbol underlyingTypeParameter) : base(containingMethod, underlyingTypeParameter) { Debug.Assert(underlyingTypeParameter.IsDefinition); }
public static bool HaveSameConstraints(TypeParameterSymbol typeParameter1, TypeMap typeMap1, TypeParameterSymbol typeParameter2, TypeMap typeMap2) { // Spec 13.4.3: Implementation of generic methods. if ((typeParameter1.HasConstructorConstraint != typeParameter2.HasConstructorConstraint) || (typeParameter1.HasReferenceTypeConstraint != typeParameter2.HasReferenceTypeConstraint) || (typeParameter1.HasValueTypeConstraint != typeParameter2.HasValueTypeConstraint) || (typeParameter1.HasUnmanagedTypeConstraint != typeParameter2.HasUnmanagedTypeConstraint) || (typeParameter1.Variance != typeParameter2.Variance)) { return(false); } // Check that constraintTypes1 is a subset of constraintTypes2 and // also that constraintTypes2 is a subset of constraintTypes1 // (see SymbolPreparer::CheckImplicitImplConstraints). var constraintTypes1 = typeParameter1.ConstraintTypesNoUseSiteDiagnostics; var constraintTypes2 = typeParameter2.ConstraintTypesNoUseSiteDiagnostics; // The two sets of constraints may differ in size but still be considered // the same (duplicated constraints, ignored "object" constraints), but // if both are zero size, the sets must be equal. if ((constraintTypes1.Length == 0) && (constraintTypes2.Length == 0)) { return(true); } var substitutedTypes1 = new HashSet <TypeSymbol>(TypeSymbol.EqualsIgnoringDynamicAndTupleNamesComparer); var substitutedTypes2 = new HashSet <TypeSymbol>(TypeSymbol.EqualsIgnoringDynamicAndTupleNamesComparer); SubstituteConstraintTypes(constraintTypes1, typeMap1, substitutedTypes1); SubstituteConstraintTypes(constraintTypes2, typeMap2, substitutedTypes2); return(AreConstraintTypesSubset(substitutedTypes1, substitutedTypes2, typeParameter2) && AreConstraintTypesSubset(substitutedTypes2, substitutedTypes1, typeParameter1)); }
private static bool IsVarianceUnsafe <T>( TypeSymbol type, bool requireOutputSafety, bool requireInputSafety, Symbol context, LocationProvider <T> locationProvider, T locationArg, BindingDiagnosticBag diagnostics ) where T : Symbol { Debug.Assert(requireOutputSafety || requireInputSafety); // A type T is "output-unsafe" ["input-unsafe"] if one of the following holds: switch (type.Kind) { case SymbolKind.TypeParameter: // 1) T is a contravariant [covariant] type parameter TypeParameterSymbol typeParam = (TypeParameterSymbol)type; if ( requireInputSafety && requireOutputSafety && typeParam.Variance != VarianceKind.None ) { // This sub-case isn't mentioned in the spec, because it's not required for // the definition. It just allows us to give a better error message for // type parameters that are both output-unsafe and input-unsafe. diagnostics.AddVarianceError( typeParam, context, locationProvider, locationArg, MessageID.IDS_Invariantly ); return(true); } else if (requireOutputSafety && typeParam.Variance == VarianceKind.In) { // The is output-unsafe case (1) from the spec. diagnostics.AddVarianceError( typeParam, context, locationProvider, locationArg, MessageID.IDS_Covariantly ); return(true); } else if (requireInputSafety && typeParam.Variance == VarianceKind.Out) { // The is input-unsafe case (1) from the spec. diagnostics.AddVarianceError( typeParam, context, locationProvider, locationArg, MessageID.IDS_Contravariantly ); return(true); } else { return(false); } case SymbolKind.ArrayType: // 2) T is an array type with an output-unsafe [input-unsafe] element type return(IsVarianceUnsafe( ((ArrayTypeSymbol)type).ElementType, requireOutputSafety, requireInputSafety, context, locationProvider, locationArg, diagnostics )); case SymbolKind.ErrorType: case SymbolKind.NamedType: var namedType = (NamedTypeSymbol)type; // 3) (see IsVarianceUnsafe(NamedTypeSymbol)) return(IsVarianceUnsafe( namedType, requireOutputSafety, requireInputSafety, context, locationProvider, locationArg, diagnostics )); default: return(false); } }
/// <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.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[i].Type; 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 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.TypeArguments[reducedFromTypeParameter.Ordinal]; }
protected virtual TypeSymbol SubstituteTypeParameter(TypeParameterSymbol typeParameter) { return(typeParameter); }
// Based on SymbolLoader::SetOverrideConstraints. private static void CheckOverrideConstraints( TypeParameterSymbol typeParameter, TypeParameterBounds bounds, ArrayBuilder<TypeParameterDiagnosticInfo> diagnosticsBuilder) { var deducedBase = bounds.DeducedBaseType; var constraintTypes = bounds.ConstraintTypes; if (IsValueType(typeParameter, constraintTypes) && IsReferenceType(typeParameter, constraintTypes)) { Debug.Assert(!deducedBase.IsValueType || typeParameter.HasReferenceTypeConstraint); diagnosticsBuilder.Add(GenerateConflictingConstraintsError(typeParameter, deducedBase, classConflict: deducedBase.IsValueType)); } else if (deducedBase.IsNullableType() && (typeParameter.HasValueTypeConstraint || typeParameter.HasReferenceTypeConstraint)) { diagnosticsBuilder.Add(GenerateConflictingConstraintsError(typeParameter, deducedBase, classConflict: typeParameter.HasReferenceTypeConstraint)); } }
private static bool AppendUseSiteDiagnostics( HashSet<DiagnosticInfo> useSiteDiagnostics, TypeParameterSymbol typeParameter, ref ArrayBuilder<TypeParameterDiagnosticInfo> useSiteDiagnosticsBuilder) { if (useSiteDiagnostics.IsNullOrEmpty()) { return false; } if (useSiteDiagnosticsBuilder == null) { useSiteDiagnosticsBuilder = new ArrayBuilder<TypeParameterDiagnosticInfo>(); } bool hasErrors = false; foreach (var info in useSiteDiagnostics) { if (info.Severity == DiagnosticSeverity.Error) { hasErrors = true; } useSiteDiagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, info)); } return hasErrors; }
public SynthesizedTypeParameterSymbol(Symbol owner, TypeMap map, TypeParameterSymbol substitutedFrom) : base(owner, map, substitutedFrom) { }
private static TypeParameterDiagnosticInfo GenerateConflictingConstraintsError(TypeParameterSymbol typeParameter, TypeSymbol deducedBase, bool classConflict) { // "Type parameter '{0}' inherits conflicting constraints '{1}' and '{2}'" return new TypeParameterDiagnosticInfo(typeParameter, new CSDiagnosticInfo(ErrorCode.ERR_BaseConstraintConflict, typeParameter, deducedBase, classConflict ? "class" : "struct")); }
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, 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> /// Return true if the given type contains the specified type parameter. /// </summary> private static bool Contains(TypeSymbol type, TypeParameterSymbol typeParam) { switch (type.Kind) { case SymbolKind.ArrayType: return Contains(((ArrayTypeSymbol)type).ElementType, typeParam); case SymbolKind.PointerType: return Contains(((PointerTypeSymbol)type).PointedAtType, typeParam); case SymbolKind.NamedType: case SymbolKind.ErrorType: { NamedTypeSymbol namedType = (NamedTypeSymbol)type; while ((object)namedType != null) { ImmutableArray<TypeSymbol> typeParts = namedType.IsTupleType ? namedType.TupleElementTypes : namedType.TypeArgumentsNoUseSiteDiagnostics; foreach (TypeSymbol typePart in typeParts) { if (Contains(typePart, typeParam)) { return true; } } namedType = namedType.ContainingType; } return false; } case SymbolKind.TypeParameter: return type == typeParam; default: return false; } }
public WrappedTypeParameterSymbol(TypeParameterSymbol underlyingTypeParameter) { Debug.Assert((object)underlyingTypeParameter != null); _underlyingTypeParameter = underlyingTypeParameter; }
/// <summary> /// Returns true if the first set of constraint types /// is a subset of the second set. /// </summary> private static bool AreConstraintTypesSubset(HashSet <TypeSymbol> constraintTypes1, HashSet <TypeSymbol> constraintTypes2, TypeParameterSymbol typeParameter2) { foreach (var constraintType in constraintTypes1) { // Skip object type (spec. 13.4.3). if (constraintType.SpecialType == SpecialType.System_Object) { continue; } if (constraintTypes2.Contains(constraintType)) { continue; } // The struct constraint implies a System.ValueType constraint // type which may be explicit in the other type parameter // constraints (through type substitution in derived types). if ((constraintType.SpecialType == SpecialType.System_ValueType) && typeParameter2.HasValueTypeConstraint) { continue; } return(false); } return(true); }
internal override void GenerateMethodBody(TypeCompilationState compilationState, DiagnosticBag diagnostics) { AnonymousTypeManager manager = ((AnonymousTypeTemplateSymbol)this.ContainingType).Manager; SyntheticBoundNodeFactory F = this.CreateBoundNodeFactory(compilationState, diagnostics); // Method body: // // HASH_FACTOR = 0xa5555529; // INIT_HASH = (...((0 * HASH_FACTOR) + backingFld_1.Name.GetHashCode()) * HASH_FACTOR // + backingFld_2.Name.GetHashCode()) * HASH_FACTOR // + ... // + backingFld_N.Name.GetHashCode() // // { // return (...((INITIAL_HASH * HASH_FACTOR) + EqualityComparer<T_1>.Default.GetHashCode(this.backingFld_1)) * HASH_FACTOR // + EqualityComparer<T_2>.Default.GetHashCode(this.backingFld_2)) * HASH_FACTOR // ... // + EqualityComparer<T_N>.Default.GetHashCode(this.backingFld_N) // } const int HASH_FACTOR = -1521134295; // (int)0xa5555529 // Type expression AnonymousTypeTemplateSymbol anonymousType = (AnonymousTypeTemplateSymbol)this.ContainingType; // INIT_HASH int initHash = 0; foreach (var property in anonymousType.Properties) { initHash = unchecked (initHash * HASH_FACTOR + property.BackingField.Name.GetHashCode()); } // Generate expression for return statement // retExpression <= 'INITIAL_HASH' BoundExpression retExpression = F.Literal(initHash); // prepare symbols MethodSymbol equalityComparer_GetHashCode = manager.System_Collections_Generic_EqualityComparer_T__GetHashCode; MethodSymbol equalityComparer_get_Default = manager.System_Collections_Generic_EqualityComparer_T__get_Default; NamedTypeSymbol equalityComparerType = equalityComparer_GetHashCode.ContainingType; // bound HASH_FACTOR BoundLiteral boundHashFactor = F.Literal(HASH_FACTOR); // Process fields for (int index = 0; index < anonymousType.Properties.Length; index++) { // Prepare constructed symbols TypeParameterSymbol typeParameter = anonymousType.TypeParameters[index]; NamedTypeSymbol constructedEqualityComparer = equalityComparerType.Construct(typeParameter); // Generate 'retExpression' <= 'retExpression * HASH_FACTOR retExpression = F.Binary(BinaryOperatorKind.IntMultiplication, manager.System_Int32, retExpression, boundHashFactor); // Generate 'retExpression' <= 'retExpression + EqualityComparer<T_index>.Default.GetHashCode(this.backingFld_index)' retExpression = F.Binary(BinaryOperatorKind.IntAddition, manager.System_Int32, retExpression, F.Call( F.StaticCall(constructedEqualityComparer, equalityComparer_get_Default.AsMember(constructedEqualityComparer)), equalityComparer_GetHashCode.AsMember(constructedEqualityComparer), F.Field(F.This(), anonymousType.Properties[index].BackingField))); } // Create a bound block F.CloseMethod(F.Block(F.Return(retExpression))); }
private static void CheckConstraints( TypeParameterSymbol typeParameter, TypeParameterConstraintKind constraints, bool isValueType, bool isReferenceType, string effectiveBaseClassDescription, string deducedBaseTypeDescription, params string[] constraintTypeDescriptions) { Assert.Equal(constraints, Utils.GetTypeParameterConstraints(typeParameter)); Assert.Equal(typeParameter.IsValueType, isValueType); Assert.Equal(typeParameter.IsReferenceType, isReferenceType); Assert.Null(typeParameter.BaseType); Assert.Equal(typeParameter.Interfaces.Length, 0); Utils.CheckSymbol(typeParameter.EffectiveBaseClassNoUseSiteDiagnostics, effectiveBaseClassDescription); Utils.CheckSymbol(typeParameter.DeducedBaseTypeNoUseSiteDiagnostics, deducedBaseTypeDescription); Utils.CheckSymbols(typeParameter.ConstraintTypes, constraintTypeDescriptions); }
/// <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(); }