/// <summary> /// Checks if 'symbol' is accessible from within named type 'within'. If 'symbol' is accessed off /// of an expression then 'throughTypeOpt' is the type of that expression. This is needed to /// properly do protected access checks. /// </summary> public static bool IsSymbolAccessible( Symbol symbol, NamedTypeSymbol within, NamedTypeSymbol throughTypeOpt = null) { if ((object)symbol == null) { throw new ArgumentNullException("symbol"); } if ((object)within == null) { throw new ArgumentNullException("within"); } HashSet <DiagnosticInfo> useSiteDiagnostics = null; return(AccessCheck.IsSymbolAccessible( symbol, within, ref useSiteDiagnostics, throughTypeOpt)); }
public static bool IsSymbolAccessible( Symbol symbol, NamedTypeSymbol within, NamedTypeSymbol throughTypeOpt = null) { if ((object)symbol == null) { throw new ArgumentNullException(nameof(symbol)); } if ((object)within == null) { throw new ArgumentNullException(nameof(within)); } var discardedUseSiteInfo = CompoundUseSiteInfo <AssemblySymbol> .Discarded; return(AccessCheck.IsSymbolAccessible( symbol, within, ref discardedUseSiteInfo, throughTypeOpt)); }
internal static BoundCall GenerateObjectConstructorInitializer(MethodSymbol constructor, DiagnosticBag diagnostics) { NamedTypeSymbol objectType = constructor.ContainingType.BaseTypeNoUseSiteDiagnostics; Debug.Assert(objectType.SpecialType == SpecialType.System_Object); MethodSymbol objectConstructor = null; LookupResultKind resultKind = LookupResultKind.Viable; foreach (MethodSymbol objectCtor in objectType.InstanceConstructors) { if (objectCtor.ParameterCount == 0) { objectConstructor = objectCtor; break; } } // UNDONE: If this happens then something is deeply wrong. Should we give a better error? if ((object)objectConstructor == null) { diagnostics.Add(ErrorCode.ERR_BadCtorArgCount, constructor.Locations[0], objectType, /*desired param count*/ 0); return(null); } // UNDONE: If this happens then something is deeply wrong. Should we give a better error? bool hasErrors = false; HashSet <DiagnosticInfo> useSiteDiagnostics = null; if (!AccessCheck.IsSymbolAccessible(objectConstructor, constructor.ContainingType, ref useSiteDiagnostics)) { diagnostics.Add(ErrorCode.ERR_BadAccess, constructor.Locations[0], objectConstructor); resultKind = LookupResultKind.Inaccessible; hasErrors = true; } if (!useSiteDiagnostics.IsNullOrEmpty()) { diagnostics.Add(constructor.Locations.IsEmpty ? NoLocation.Singleton : constructor.Locations[0], useSiteDiagnostics); } CSharpSyntaxNode syntax = constructor.GetNonNullSyntaxNode(); BoundExpression receiver = new BoundThisReference(syntax, constructor.ContainingType) { WasCompilerGenerated = true }; return(new BoundCall( syntax: syntax, receiverOpt: receiver, method: objectConstructor, arguments: ImmutableArray <BoundExpression> .Empty, argumentNamesOpt: ImmutableArray <string> .Empty, argumentRefKindsOpt: ImmutableArray <RefKind> .Empty, isDelegateCall: false, expanded: false, invokedAsExtensionMethod: false, argsToParamsOpt: ImmutableArray <int> .Empty, resultKind: resultKind, type: objectType, hasErrors: hasErrors) { WasCompilerGenerated = true }); }
private FieldSymbol GetActualInstanceField(Symbol member, NamedTypeSymbol type) { if (!member.IsStatic) { HashSet <DiagnosticInfo> useSiteDiagnostics = null; switch (member.Kind) { case SymbolKind.Field: var field = (FieldSymbol)member; if (!field.IsFixed && ((object)this.accessor == null || AccessCheck.IsSymbolAccessible(field, this.accessor, ref useSiteDiagnostics))) { return(field.AsMember(type)); } break; case SymbolKind.Event: EventSymbol eventSymbol = (EventSymbol)member; if (eventSymbol.HasAssociatedField && ((object)this.accessor == null || AccessCheck.IsSymbolAccessible(eventSymbol, this.accessor, ref useSiteDiagnostics))) { return(eventSymbol.AssociatedField.AsMember(type)); } break; } } return(null); }