public EmbeddedProperty( PropertySymbolAdapter underlyingProperty, EmbeddedMethod getter, EmbeddedMethod setter ) : base(underlyingProperty, getter, setter) { }
public SynthesizedImplementationMethod( MethodSymbol interfaceMethod, NamedTypeSymbol implementingType, string name = null, bool debuggerHidden = false, PropertySymbol associatedProperty = null, MethodSymbol asyncKickoffMethod = null) { //it does not make sense to add methods to substituted types Debug.Assert(implementingType.IsDefinition); this.name = name ?? ExplicitInterfaceHelpers.GetMemberName(interfaceMethod.Name, interfaceMethod.ContainingType, aliasQualifierOpt: null); this.interfaceMethod = interfaceMethod; this.implementingType = implementingType; this.debuggerHidden = debuggerHidden; this.associatedProperty = associatedProperty; this.explicitInterfaceImplementations = ImmutableArray.Create<MethodSymbol>(interfaceMethod); this.asyncKickoffMethod = asyncKickoffMethod; // alpha-rename to get the implementation's type parameters var typeMap = interfaceMethod.ContainingType.TypeSubstitution ?? TypeMap.Empty; typeMap.WithAlphaRename(interfaceMethod, this, out this.typeParameters); var substitutedInterfaceMethod = interfaceMethod.ConstructIfGeneric(this.typeParameters.Cast<TypeParameterSymbol, TypeSymbol>()); this.returnType = substitutedInterfaceMethod.ReturnType; this.parameters = SynthesizedParameterSymbol.DeriveParameters(substitutedInterfaceMethod, this); }
private BoundExpression MakePropertyGetAccess( SyntaxNode syntax, BoundExpression rewrittenReceiver, PropertySymbol property, ImmutableArray<BoundExpression> rewrittenArguments, MethodSymbol getMethodOpt = null, BoundPropertyAccess oldNodeOpt = null) { if (_inExpressionLambda && rewrittenArguments.IsEmpty) { return oldNodeOpt != null ? oldNodeOpt.Update(rewrittenReceiver, property, LookupResultKind.Viable, property.Type) : new BoundPropertyAccess(syntax, rewrittenReceiver, property, LookupResultKind.Viable, property.Type); } else { var getMethod = getMethodOpt ?? property.GetOwnOrInheritedGetMethod(); Debug.Assert((object)getMethod != null); Debug.Assert(getMethod.ParameterCount == rewrittenArguments.Length); Debug.Assert(((object)getMethodOpt == null) || ReferenceEquals(getMethod, getMethodOpt)); return BoundCall.Synthesized( syntax, rewrittenReceiver, getMethod, rewrittenArguments); } }
public static SourcePropertyAccessorSymbol CreateAccessorSymbol( NamedTypeSymbol containingType, SourcePropertySymbol property, DeclarationModifiers propertyModifiers, string propertyName, ArrowExpressionClauseSyntax syntax, PropertySymbol explicitlyImplementedPropertyOpt, string aliasQualifierOpt, DiagnosticBag diagnostics) { string name; ImmutableArray<MethodSymbol> explicitInterfaceImplementations; GetNameAndExplicitInterfaceImplementations( explicitlyImplementedPropertyOpt, propertyName, property.IsCompilationOutputWinMdObj(), aliasQualifierOpt, isGetMethod: true, name: out name, explicitInterfaceImplementations: out explicitInterfaceImplementations); return new SourcePropertyAccessorSymbol( containingType, name, property, propertyModifiers, explicitInterfaceImplementations, syntax.Expression.GetLocation(), syntax, diagnostics); }
public SynthesizedImplementationMethod( MethodSymbol interfaceMethod, NamedTypeSymbol implementingType, string name = null, bool generateDebugInfo = true, PropertySymbol associatedProperty = null) { //it does not make sense to add methods to substituted types Debug.Assert(implementingType.IsDefinition); _name = name ?? ExplicitInterfaceHelpers.GetMemberName(interfaceMethod.Name, interfaceMethod.ContainingType, aliasQualifierOpt: null); _interfaceMethod = interfaceMethod; _implementingType = implementingType; _generateDebugInfo = generateDebugInfo; _associatedProperty = associatedProperty; _explicitInterfaceImplementations = ImmutableArray.Create<MethodSymbol>(interfaceMethod); // alpha-rename to get the implementation's type parameters var typeMap = interfaceMethod.ContainingType.TypeSubstitution ?? TypeMap.Empty; typeMap.WithAlphaRename(interfaceMethod, this, out _typeParameters); var substitutedInterfaceMethod = interfaceMethod.ConstructIfGeneric(_typeParameters.Cast<TypeParameterSymbol, TypeSymbol>()); _returnType = substitutedInterfaceMethod.ReturnType; _parameters = SynthesizedParameterSymbol.DeriveParameters(substitutedInterfaceMethod, this); }
public RetargetingPropertySymbol(RetargetingModuleSymbol retargetingModule, PropertySymbol underlyingProperty) : base(underlyingProperty) { Debug.Assert((object)retargetingModule != null); Debug.Assert(!(underlyingProperty is RetargetingPropertySymbol)); _retargetingModule = retargetingModule; }
public RetargetingPropertySymbol(RetargetingModuleSymbol retargetingModule, PropertySymbol underlyingProperty) { Debug.Assert((object)retargetingModule != null); Debug.Assert((object)underlyingProperty != null); Debug.Assert(!(underlyingProperty is RetargetingPropertySymbol)); this.retargetingModule = retargetingModule; this.underlyingProperty = underlyingProperty; }
public SynthesizedSealedPropertyAccessor(PropertySymbol property, MethodSymbol overriddenAccessor) { Debug.Assert((object)property != null); Debug.Assert(property.IsSealed); Debug.Assert((object)overriddenAccessor != null); _property = property; _overriddenAccessor = overriddenAccessor; _parameters = SynthesizedParameterSymbol.DeriveParameters(overriddenAccessor, this); }
protected SynthesizedStateMachineMethod( string name, MethodSymbol interfaceMethod, StateMachineTypeSymbol stateMachineType, PropertySymbol associatedProperty, bool generateDebugInfo, bool hasMethodBodyDependency) : base(interfaceMethod, stateMachineType, name, generateDebugInfo, associatedProperty) { _hasMethodBodyDependency = hasMethodBodyDependency; }
public override void VisitProperty(PropertySymbol symbol) { var sourceProperty = symbol as SourcePropertySymbol; if ((object)sourceProperty != null && sourceProperty.IsSealed) { var synthesizedAccessor = sourceProperty.SynthesizedSealedAccessorOpt; if ((object)synthesizedAccessor != null) { moduleBeingBuilt.AddCompilerGeneratedDefinition(sourceProperty.ContainingType, synthesizedAccessor); } } }
public SynthesizedStateMachineMethod( string name, MethodSymbol interfaceMethod, NamedTypeSymbol implementingType, MethodSymbol asyncKickoffMethod, PropertySymbol associatedProperty, bool debuggerHidden, bool hasMethodBodyDependency) : base(interfaceMethod, implementingType, name, debuggerHidden, associatedProperty, asyncKickoffMethod) { this.hasMethodBodyDependency = hasMethodBodyDependency; }
public static SourcePropertyAccessorSymbol CreateAccessorSymbol( NamedTypeSymbol containingType, SourcePropertySymbol property, DeclarationModifiers propertyModifiers, string propertyName, AccessorDeclarationSyntax syntax, PropertySymbol explicitlyImplementedPropertyOpt, string aliasQualifierOpt, bool isAutoPropertyAccessor, DiagnosticBag diagnostics) { Debug.Assert(syntax.Kind == SyntaxKind.GetAccessorDeclaration || syntax.Kind == SyntaxKind.SetAccessorDeclaration); bool isGetMethod = (syntax.Kind == SyntaxKind.GetAccessorDeclaration); bool isWinMd = property.IsCompilationOutputWinMdObj(); string name; ImmutableArray<MethodSymbol> explicitInterfaceImplementations; if ((object)explicitlyImplementedPropertyOpt == null) { name = GetAccessorName(propertyName, isGetMethod, isWinMd); explicitInterfaceImplementations = ImmutableArray<MethodSymbol>.Empty; } else { MethodSymbol implementedAccessor = isGetMethod ? explicitlyImplementedPropertyOpt.GetMethod : explicitlyImplementedPropertyOpt.SetMethod; string accessorName = (object)implementedAccessor != null ? implementedAccessor.Name : GetAccessorName(explicitlyImplementedPropertyOpt.MetadataName, isGetMethod, isWinMd); //Not name - could be indexer placeholder name = ExplicitInterfaceHelpers.GetMemberName(accessorName, explicitlyImplementedPropertyOpt.ContainingType, aliasQualifierOpt); explicitInterfaceImplementations = (object)implementedAccessor == null ? ImmutableArray<MethodSymbol>.Empty : ImmutableArray.Create<MethodSymbol>(implementedAccessor); } var methodKind = isGetMethod ? MethodKind.PropertyGet : MethodKind.PropertySet; return new SourcePropertyAccessorSymbol( containingType, name, property, propertyModifiers, explicitInterfaceImplementations, syntax.Keyword.GetLocation(), syntax, methodKind, isAutoPropertyAccessor, diagnostics); }
private BoundExpression MakePropertyAccess( SyntaxNode syntax, BoundExpression rewrittenReceiverOpt, PropertySymbol propertySymbol, LookupResultKind resultKind, TypeSymbol type, bool isLeftOfAssignment, BoundPropertyAccess oldNodeOpt = null) { // check for System.Array.[Length|LongLength] on a single dimensional array, // we have a special node for such cases. if (rewrittenReceiverOpt != null && rewrittenReceiverOpt.Type.IsArray() && !isLeftOfAssignment) { var asArrayType = (ArrayTypeSymbol)rewrittenReceiverOpt.Type; if (asArrayType.IsSZArray) { // NOTE: we are not interested in potential badness of Array.Length property. // If it is bad reference compare will not succeed. if (ReferenceEquals(propertySymbol, _compilation.GetSpecialTypeMember(SpecialMember.System_Array__Length)) || !_inExpressionLambda && ReferenceEquals(propertySymbol, _compilation.GetSpecialTypeMember(SpecialMember.System_Array__LongLength))) { return new BoundArrayLength(syntax, rewrittenReceiverOpt, type); } } } if (isLeftOfAssignment && propertySymbol.RefKind == RefKind.None) { // This is a property set access. We return a BoundPropertyAccess node here. // This node will be rewritten with MakePropertyAssignment when rewriting the enclosing BoundAssignmentOperator. return oldNodeOpt != null ? oldNodeOpt.Update(rewrittenReceiverOpt, propertySymbol, resultKind, type) : new BoundPropertyAccess(syntax, rewrittenReceiverOpt, propertySymbol, resultKind, type); } else { // This is a property get access return MakePropertyGetAccess(syntax, rewrittenReceiverOpt, propertySymbol, oldNodeOpt); } }
internal AsyncMethodBuilderMemberCollection( NamedTypeSymbol builderType, TypeSymbol resultType, MethodSymbol setException, MethodSymbol setResult, MethodSymbol awaitOnCompleted, MethodSymbol awaitUnsafeOnCompleted, MethodSymbol start, MethodSymbol setStateMachine, PropertySymbol task) { BuilderType = builderType; ResultType = resultType; SetException = setException; SetResult = setResult; AwaitOnCompleted = awaitOnCompleted; AwaitUnsafeOnCompleted = awaitUnsafeOnCompleted; Start = start; SetStateMachine = setStateMachine; Task = task; }
public static SourcePropertyAccessorSymbol CreateAccessorSymbol( NamedTypeSymbol containingType, SourcePropertySymbol property, DeclarationModifiers propertyModifiers, string propertyName, AccessorDeclarationSyntax syntax, PropertySymbol explicitlyImplementedPropertyOpt, string aliasQualifierOpt, bool isAutoPropertyAccessor, DiagnosticBag diagnostics) { Debug.Assert(syntax.Kind() == SyntaxKind.GetAccessorDeclaration || syntax.Kind() == SyntaxKind.SetAccessorDeclaration); bool isGetMethod = (syntax.Kind() == SyntaxKind.GetAccessorDeclaration); string name; ImmutableArray<MethodSymbol> explicitInterfaceImplementations; GetNameAndExplicitInterfaceImplementations( explicitlyImplementedPropertyOpt, propertyName, property.IsCompilationOutputWinMdObj(), aliasQualifierOpt, isGetMethod, out name, out explicitInterfaceImplementations); var methodKind = isGetMethod ? MethodKind.PropertyGet : MethodKind.PropertySet; return new SourcePropertyAccessorSymbol( containingType, name, property, propertyModifiers, explicitInterfaceImplementations, syntax.Keyword.GetLocation(), syntax, methodKind, isAutoPropertyAccessor, diagnostics); }
public virtual void VisitProperty(PropertySymbol symbol) { DefaultVisit(symbol); }
private PropertySymbol VisitPropertySymbol(PropertySymbol property) { if ((object)property == null) { return null; } if (!property.ContainingType.IsAnonymousType) { // Property of a regular type return ((PropertySymbol)property.OriginalDefinition) .AsMember((NamedTypeSymbol)TypeMap.SubstituteType(property.ContainingType).AsTypeSymbolOnly()); } // Method of an anonymous type var newType = (NamedTypeSymbol)TypeMap.SubstituteType(property.ContainingType).AsTypeSymbolOnly(); if (ReferenceEquals(newType, property.ContainingType)) { // Anonymous type symbol was not rewritten return property; } // get a new property by name foreach (var member in newType.GetMembers(property.Name)) { if (member.Kind == SymbolKind.Property) { return (PropertySymbol)member; } } throw ExceptionUtilities.Unreachable; }
internal static bool AccessingAutopropertyFromConstructor(BoundExpression receiver, PropertySymbol propertySymbol, Symbol fromMember) { var sourceProperty = propertySymbol as SourcePropertySymbol; var propertyIsStatic = propertySymbol.IsStatic; return (object)sourceProperty != null && sourceProperty.IsAutoProperty && sourceProperty.ContainingType == fromMember.ContainingType && ((MethodSymbol)fromMember).MethodKind == (propertyIsStatic ? MethodKind.StaticConstructor : MethodKind.Constructor) && (propertyIsStatic || receiver.Kind == BoundKind.ThisReference); }
public EmbeddedProperty(PropertySymbol underlyingProperty, EmbeddedMethod getter, EmbeddedMethod setter) : base(underlyingProperty, getter, setter) { }
public AnonymousTypeFieldSymbol(PropertySymbol property) { Debug.Assert((object)property != null); _property = property; }
private static void CheckParameterizedProperty(PropertySymbol property, bool expectGetter, bool expectSetter, string propertyDisplayString, bool expectIndexer, bool suppressAssociatedPropertyCheck) { Assert.Equal(SymbolKind.Property, property.Kind); Assert.Equal(expectIndexer, property.IsIndexer); Assert.NotEqual(expectIndexer, property.MustCallMethodsDirectly); Assert.Equal(propertyDisplayString, property.ToTestDisplayString()); if (expectGetter) { CheckAccessorShape(property.GetMethod, true, property, expectIndexer, suppressAssociatedPropertyCheck); } else { Assert.Null(property.GetMethod); } if (expectSetter) { CheckAccessorShape(property.SetMethod, false, property, expectIndexer, suppressAssociatedPropertyCheck); } else { Assert.Null(property.SetMethod); } }
// Create AccessorSymbol for AccessorDeclarationSyntax private SourcePropertyAccessorSymbol CreateAccessorSymbol(AccessorDeclarationSyntax syntaxOpt, PropertySymbol explicitlyImplementedPropertyOpt, string aliasQualifierOpt, bool isAutoPropertyAccessor, DiagnosticBag diagnostics) { if (syntaxOpt == null) { return null; } return SourcePropertyAccessorSymbol.CreateAccessorSymbol(_containingType, this, _modifiers, _sourceName, syntaxOpt, explicitlyImplementedPropertyOpt, aliasQualifierOpt, isAutoPropertyAccessor, diagnostics); }
public static BoundIndexerAccess ErrorAccess( CSharpSyntaxNode node, BoundExpression receiverOpt, PropertySymbol indexer, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> namedArguments, ImmutableArray<RefKind> refKinds, ImmutableArray<PropertySymbol> originalIndexers) { return new BoundIndexerAccess( node, receiverOpt, indexer, arguments, namedArguments, refKinds, expanded: false, argsToParamsOpt: default(ImmutableArray<int>), type: indexer.Type, hasErrors: true) { OriginalIndexersOpt = originalIndexers }; }
private static void GetNameAndExplicitInterfaceImplementations( PropertySymbol explicitlyImplementedPropertyOpt, string propertyName, bool isWinMd, string aliasQualifierOpt, bool isGetMethod, out string name, out ImmutableArray<MethodSymbol> explicitInterfaceImplementations) { if ((object)explicitlyImplementedPropertyOpt == null) { name = GetAccessorName(propertyName, isGetMethod, isWinMd); explicitInterfaceImplementations = ImmutableArray<MethodSymbol>.Empty; } else { MethodSymbol implementedAccessor = isGetMethod ? explicitlyImplementedPropertyOpt.GetMethod : explicitlyImplementedPropertyOpt.SetMethod; string accessorName = (object)implementedAccessor != null ? implementedAccessor.Name : GetAccessorName(explicitlyImplementedPropertyOpt.MetadataName, isGetMethod, isWinMd); //Not name - could be indexer placeholder name = ExplicitInterfaceHelpers.GetMemberName(accessorName, explicitlyImplementedPropertyOpt.ContainingType, aliasQualifierOpt); explicitInterfaceImplementations = (object)implementedAccessor == null ? ImmutableArray<MethodSymbol>.Empty : ImmutableArray.Create<MethodSymbol>(implementedAccessor); } }
private static void CheckIndexer(PropertySymbol property, bool hasGet, bool hasSet, SpecialType expectedType, params SpecialType[] expectedParameterTypes) { Assert.NotNull(property); Assert.True(property.IsIndexer); Assert.Equal(property.Type.SpecialType, expectedType); CheckParameters(property.Parameters, expectedParameterTypes); var getter = property.GetMethod; if (hasGet) { Assert.NotNull(getter); Assert.Equal(getter.ReturnType.SpecialType, expectedType); CheckParameters(getter.Parameters, expectedParameterTypes); } else { Assert.Null(getter); } var setter = property.SetMethod; if (hasSet) { Assert.NotNull(setter); Assert.True(setter.ReturnsVoid); CheckParameters(setter.Parameters, expectedParameterTypes.Concat(new[] { expectedType }).ToArray()); } else { Assert.Null(setter); } Assert.Equal(property.GetMethod != null, hasGet); Assert.Equal(property.SetMethod != null, hasSet); }
private static bool AccessingAutoPropertyFromConstructor(BoundExpression receiver, PropertySymbol propertySymbol, Symbol fromMember) { var sourceProperty = propertySymbol as SourcePropertySymbol; var propertyIsStatic = propertySymbol.IsStatic; return (object)sourceProperty != null && sourceProperty.IsAutoProperty && sourceProperty.ContainingType == fromMember.ContainingType && IsConstructorOrField(fromMember, isStatic: propertyIsStatic) && (propertyIsStatic || receiver.Kind == BoundKind.ThisReference); }
public WrappedPropertySymbol(PropertySymbol underlyingProperty) { Debug.Assert((object)underlyingProperty != null); _underlyingProperty = underlyingProperty; }
public SynthesizedRecordGetHashCode(SourceMemberContainerTypeSymbol containingType, PropertySymbol equalityContract, int memberOffset, DiagnosticBag diagnostics) : base(containingType, WellKnownMemberNames.ObjectGetHashCode, memberOffset, diagnostics) { _equalityContract = equalityContract; }
internal SubstitutedPropertySymbol(SubstitutedNamedTypeSymbol containingType, PropertySymbol originalDefinition) : base(originalDefinition) { _containingType = containingType; }
private static void CheckIndexer(PropertySymbol indexer, bool expectGetter, bool expectSetter, string indexerDisplayString, bool suppressAssociatedPropertyCheck = false) { CheckParameterizedProperty(indexer, expectGetter, expectSetter, indexerDisplayString, true, suppressAssociatedPropertyCheck); }
internal SubstitutedParameterSymbol(PropertySymbol containingSymbol, TypeMap map, ParameterSymbol originalParameter) : this((Symbol)containingSymbol, map, originalParameter) { }
private static void CheckNonIndexer(PropertySymbol property, bool expectGetter, bool expectSetter, string propertyDisplayString) { CheckParameterizedProperty(property, expectGetter, expectSetter, propertyDisplayString, false, true); }
public SynthesizedRecordGetHashCode(NamedTypeSymbol containingType, PropertySymbol equalityContract, int memberOffset) { _memberOffset = memberOffset; ContainingType = containingType; _equalityContract = equalityContract; }
private static void CheckAccessorShape(MethodSymbol accessor, bool accessorIsGetMethod, PropertySymbol property, bool propertyIsIndexer, bool suppressAssociatedPropertyCheck) { Assert.NotNull(accessor); if (propertyIsIndexer) { if (!suppressAssociatedPropertyCheck) { Assert.Same(property, accessor.AssociatedSymbol); } } else { Assert.Null(accessor.AssociatedSymbol); Assert.Equal(MethodKind.Ordinary, accessor.MethodKind); } if (accessorIsGetMethod) { Assert.Equal(propertyIsIndexer ? MethodKind.PropertyGet : MethodKind.Ordinary, accessor.MethodKind); Assert.Equal(property.Type, accessor.ReturnType); Assert.Equal(property.ParameterCount, accessor.ParameterCount); } else { Assert.Equal(propertyIsIndexer ? MethodKind.PropertySet : MethodKind.Ordinary, accessor.MethodKind); Assert.Equal(SpecialType.System_Void, accessor.ReturnType.SpecialType); Assert.Equal(property.Type, accessor.Parameters.Last().Type); Assert.Equal(property.ParameterCount + 1, accessor.ParameterCount); } // NOTE: won't check last param of setter - that was handled above. for (int i = 0; i < property.ParameterCount; i++) { Assert.Equal(property.Parameters[i].Type, accessor.Parameters[i].Type); } Assert.Equal(property.IsAbstract, accessor.IsAbstract); Assert.Equal(property.IsOverride, @accessor.IsOverride); Assert.Equal(property.IsVirtual, @accessor.IsVirtual); Assert.Equal(property.IsSealed, @accessor.IsSealed); Assert.Equal(property.IsExtern, @accessor.IsExtern); }
/// <summary> /// Helper method specifically for TestPropertyOverrideCombinations. /// </summary> /// <param name="property">Must have array type.</param> /// <param name="inType">True if a custom modifier is expected on the return type array element type.</param> /// <param name="onType">True if a custom modifier is expected on the return type.</param> private static void CheckPropertyCustomModifiers(PropertySymbol property, bool inType, bool onType) { CheckCustomModifier(inType, ((ArrayTypeSymbol)property.Type).CustomModifiers); CheckCustomModifier(onType, property.TypeCustomModifiers); }
// Separate these checks out of FindExplicitlyImplementedProperty because they depend on the accessor symbols, // which depend on the explicitly implemented property private void CheckExplicitImplementationAccessor(MethodSymbol thisAccessor, MethodSymbol otherAccessor, PropertySymbol explicitlyImplementedProperty, DiagnosticBag diagnostics) { var thisHasAccessor = (object)thisAccessor != null; var otherHasAccessor = (object)otherAccessor != null; if (otherHasAccessor && !thisHasAccessor) { diagnostics.Add(ErrorCode.ERR_ExplicitPropertyMissingAccessor, this.Location, this, otherAccessor); } else if (!otherHasAccessor && thisHasAccessor) { diagnostics.Add(ErrorCode.ERR_ExplicitPropertyAddingAccessor, thisAccessor.Locations[0], thisAccessor, explicitlyImplementedProperty); } }
/// <summary> /// Creates a SemanticModel for an autoprop initializer of a named type /// </summary> internal static InitializerSemanticModel Create(CSharpCompilation compilation, CSharpSyntaxNode syntax, PropertySymbol propertySymbol, Binder rootBinder) { Debug.Assert(syntax.IsKind(SyntaxKind.PropertyDeclaration)); return new InitializerSemanticModel(compilation, syntax, propertySymbol, rootBinder); }
public TuplePropertySymbol(TupleTypeSymbol container, PropertySymbol underlyingProperty) : base(underlyingProperty) { _containingType = container; }
public override IExpression VisitMemberAccessExpression(MemberAccessExpressionSyntax node) { var o = this.semanticModel.GetSymbolInfo(node); IExpression instance = null; BoundExpression be = null; var onLHS = this.lhs; this.lhs = false; // only the right-most member is a l-value: all other member accesses are for r-value. var s = o.Symbol; if (s != null) { switch (s.Kind) { case CommonSymbolKind.Method: R.MethodSymbol ms = (R.MethodSymbol)s; instance = null; if (!s.IsStatic) { instance = this.Visit(node.Expression); } var mr = this.mapper.Map(ms); be = new BoundExpression() { Definition = mr, Instance = instance, Locations = Helper.SourceLocation(this.tree, node), Type = mr.Type, }; return(be); case CommonSymbolKind.Field: FieldSymbol fs = (FieldSymbol)s; instance = null; if (!fs.IsStatic) { instance = this.Visit(node.Expression); } var fr = this.mapper.Map(fs); // Certain fields represent compile-time constants // REVIEW: Is this the right place to do this? // TODO: All the rest of the constants... if (fr.ContainingType.InternedKey == this.host.PlatformType.SystemInt32.InternedKey) { if (fr.Name.Value.Equals("MinValue")) { return(new CompileTimeConstant() { Type = fr.Type, Value = Int32.MinValue, }); } else if (fr.Name.Value.Equals("MaxValue")) { return(new CompileTimeConstant() { Type = fr.Type, Value = Int32.MaxValue, }); } } be = new BoundExpression() { Definition = fr, Instance = instance, Locations = Helper.SourceLocation(this.tree, node), Type = fr.Type, }; return(be); case CommonSymbolKind.Property: R.PropertySymbol ps = (R.PropertySymbol)s; instance = null; if (!ps.IsStatic) { instance = this.Visit(node.Expression); } var accessor = onLHS ? this.mapper.Map(ps.SetMethod) : this.mapper.Map(ps.GetMethod); if (!onLHS && MemberHelper.GetMemberSignature(accessor, NameFormattingOptions.None).Contains("Length")) { return(new VectorLength() { Locations = Helper.SourceLocation(this.tree, node), Type = accessor.Type, Vector = instance, }); } return(new MethodCall() { MethodToCall = accessor, IsStaticCall = ps.IsStatic, Locations = Helper.SourceLocation(this.tree, node), ThisArgument = instance, Type = accessor.Type, }); default: throw new InvalidDataException("VisitMemberAccessExpression: uknown definition kind: " + s.Kind); } } throw new InvalidDataException("VisitMemberAccessExpression couldn't find something to return"); }