Exemple #1
0
        public override BoundNode VisitObjectInitializerMember(BoundObjectInitializerMember node)
        {
            if (_inExpressionLambda && !node.Arguments.IsDefaultOrEmpty)
            {
                Error(ErrorCode.ERR_DictionaryInitializerInExpressionTree, node);
            }

            return(base.VisitObjectInitializerMember(node));
        }
Exemple #2
0
        private BoundExpression MakeObjectInitializerMemberAccess(
            BoundExpression rewrittenReceiver,
            BoundObjectInitializerMember rewrittenLeft,
            bool isRhsNestedInitializer)
        {
            var memberSymbol = rewrittenLeft.MemberSymbol;
            HashSet <DiagnosticInfo> useSiteDiagnostics = null;

            Debug.Assert(memberSymbol != null && _compilation.Conversions.ClassifyConversionFromType(rewrittenReceiver.Type, memberSymbol.ContainingType, ref useSiteDiagnostics).IsImplicit);
            // It is possible there are use site diagnostics from the above, but none that we need report as we aren't generating code for the conversion

            switch (memberSymbol.Kind)
            {
            case SymbolKind.Field:
                var fieldSymbol = (FieldSymbol)memberSymbol;
                return(MakeFieldAccess(rewrittenLeft.Syntax, rewrittenReceiver, fieldSymbol, null, rewrittenLeft.ResultKind, fieldSymbol.Type));

            case SymbolKind.Property:
                var propertySymbol = (PropertySymbol)memberSymbol;
                var arguments      = rewrittenLeft.Arguments;
                if (!arguments.IsEmpty || propertySymbol.IsIndexedProperty)
                {
                    return(MakeIndexerAccess(
                               rewrittenLeft.Syntax,
                               rewrittenReceiver,
                               propertySymbol,
                               rewrittenLeft.Arguments,
                               rewrittenLeft.ArgumentNamesOpt,
                               rewrittenLeft.ArgumentRefKindsOpt,
                               rewrittenLeft.Expanded,
                               rewrittenLeft.ArgsToParamsOpt,
                               type: propertySymbol.Type,
                               oldNodeOpt: null,
                               isLeftOfAssignment: !isRhsNestedInitializer));
                }
                else
                {
                    return(MakePropertyAccess(
                               rewrittenLeft.Syntax,
                               rewrittenReceiver,
                               propertySymbol,
                               rewrittenLeft.ResultKind,
                               propertySymbol.Type,
                               isLeftOfAssignment: !isRhsNestedInitializer));
                }

            case SymbolKind.Event:
                var eventSymbol = (EventSymbol)memberSymbol;
                return(MakeEventAccess(rewrittenLeft.Syntax, rewrittenReceiver, eventSymbol, null, rewrittenLeft.ResultKind, eventSymbol.Type));

            default:
                throw ExceptionUtilities.UnexpectedValue(memberSymbol.Kind);
            }
        }
                public override BoundNode?VisitObjectInitializerMember(BoundObjectInitializerMember node)
                {
                    // Although ref indexers are not declarable in C#, they may be usable
                    if (!node.ArgumentRefKindsOpt.IsDefault)
                    {
                        _mightAssignSomething = true;
                    }
                    else
                    {
                        base.VisitObjectInitializerMember(node);
                    }

                    return(null);
                }
        public override BoundNode VisitObjectInitializerMember(BoundObjectInitializerMember node)
        {
            if (_inExpressionLambda && !node.Arguments.IsDefaultOrEmpty)
            {
                Error(ErrorCode.ERR_DictionaryInitializerInExpressionTree, node);
            }

            return base.VisitObjectInitializerMember(node);
        }
        private BoundExpression MakeObjectInitializerMemberAccess(
            BoundExpression rewrittenReceiver,
            BoundObjectInitializerMember rewrittenLeft,
            bool isRhsNestedInitializer)
        {
            var memberSymbol = rewrittenLeft.MemberSymbol;
            HashSet<DiagnosticInfo> useSiteDiagnostics = null;
            Debug.Assert(memberSymbol != null && _compilation.Conversions.ClassifyConversionFromType(rewrittenReceiver.Type, memberSymbol.ContainingType, ref useSiteDiagnostics).IsImplicit);
            // It is possible there are use site diagnostics from the above, but none that we need report as we aren't generating code for the conversion

            switch (memberSymbol.Kind)
            {
                case SymbolKind.Field:
                    var fieldSymbol = (FieldSymbol)memberSymbol;
                    return MakeFieldAccess(rewrittenLeft.Syntax, rewrittenReceiver, fieldSymbol, null, rewrittenLeft.ResultKind, fieldSymbol.Type);

                case SymbolKind.Property:
                    var propertySymbol = (PropertySymbol)memberSymbol;
                    var arguments = rewrittenLeft.Arguments;
                    if (!arguments.IsEmpty || propertySymbol.IsIndexedProperty)
                    {
                        return MakeIndexerAccess(
                            rewrittenLeft.Syntax,
                            rewrittenReceiver,
                            propertySymbol,
                            rewrittenLeft.Arguments,
                            rewrittenLeft.ArgumentNamesOpt,
                            rewrittenLeft.ArgumentRefKindsOpt,
                            rewrittenLeft.Expanded,
                            rewrittenLeft.ArgsToParamsOpt,
                            type: propertySymbol.Type,
                            oldNodeOpt: null,
                            isLeftOfAssignment: !isRhsNestedInitializer);
                    }
                    else
                    {
                        return MakePropertyAccess(
                            rewrittenLeft.Syntax,
                            rewrittenReceiver,
                            propertySymbol,
                            rewrittenLeft.ResultKind,
                            propertySymbol.Type,
                            isLeftOfAssignment: !isRhsNestedInitializer);
                    }

                case SymbolKind.Event:
                    var eventSymbol = (EventSymbol)memberSymbol;
                    return MakeEventAccess(rewrittenLeft.Syntax, rewrittenReceiver, eventSymbol, null, rewrittenLeft.ResultKind, eventSymbol.Type);

                default:
                    throw ExceptionUtilities.UnexpectedValue(memberSymbol.Kind);
            }
        }