protected BoundNode(BoundKind kind, CSharpSyntaxNode syntax) { Debug.Assert(kind == BoundKind.SequencePoint || kind == BoundKind.SequencePointExpression || syntax != null); this.kind = kind; this.Syntax = syntax; }
protected BoundNode(BoundKind kind, CSharpSyntaxNode syntax) { Debug.Assert(kind == BoundKind.SequencePoint || kind == BoundKind.SequencePointExpression || syntax != null); _kind = kind; this.Syntax = syntax; }
protected BoundNode(BoundKind kind, SyntaxNode syntax, bool hasErrors) : this(kind, syntax) { if (hasErrors) { _attributes = BoundNodeAttributes.HasErrors; } }
protected BoundNode(BoundKind kind, CSharpSyntaxNode syntax, bool hasErrors) : this(kind, syntax) { if (hasErrors) { this.attributes = BoundNodeAttributes.HasErrors; } }
private void ReportMissingThis(BoundKind boundKind, SyntaxNode syntax) { Debug.Assert(boundKind == BoundKind.ThisReference || boundKind == BoundKind.BaseReference); var errorCode = boundKind == BoundKind.BaseReference ? ErrorCode.ERR_BaseInBadContext : ErrorCode.ERR_ThisInBadContext; _diagnostics.Add(new CSDiagnostic(new CSDiagnosticInfo(errorCode), syntax.Location)); }
public BoundProperty(BoundKind kind, BoundTree boundTree, ImmutableArray <object> childBoundNodes, string name, Optional <object> valueOpt, SymbolPropertyOwner owner, Type ownerType, LanguageSyntaxNode syntax, bool hasErrors = false) : base(kind, boundTree, childBoundNodes, syntax, hasErrors) { _name = name; _hasFixedValue = valueOpt.HasValue; _value = valueOpt.HasValue ? valueOpt.Value : default; _owner = owner; _ownerType = ownerType; }
protected BoundNode(BoundKind kind, SyntaxNode syntax) { Debug.Assert( kind == BoundKind.SequencePoint || kind == BoundKind.SequencePointExpression || kind == (BoundKind)byte.MaxValue || // used in SpillSequenceSpiller syntax != null); _kind = kind; this.Syntax = syntax; }
// Rewrite object initializer member assignment and add it to the result. // new SomeType { Member = 0 }; // ~~~~~~~~~~ private void AddObjectInitializer(ref ArrayBuilder <BoundExpression> dynamicSiteInitializers, ArrayBuilder <BoundExpression> result, BoundExpression rewrittenReceiver, BoundAssignmentOperator assignment) { Debug.Assert(rewrittenReceiver != null); Debug.Assert(!inExpressionLambda); // Update the receiver for the field/property access as we might have introduced a temp for the initializer rewrite. BoundExpression rewrittenLeft = VisitExpression(assignment.Left); BoundKind rhsKind = assignment.Right.Kind; bool isRhsNestedInitializer = rhsKind == BoundKind.ObjectInitializerExpression || rhsKind == BoundKind.CollectionInitializerExpression; BoundExpression rewrittenAccess; if (rewrittenLeft.Kind == BoundKind.ObjectInitializerMember) { rewrittenAccess = MakeObjectInitializerMemberAccess(rewrittenReceiver, (BoundObjectInitializerMember)rewrittenLeft, isRhsNestedInitializer); if (!isRhsNestedInitializer) { // Rewrite simple assignment to field/property. var rewrittenRight = VisitExpression(assignment.Right); result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, assignment.Type, used: false)); return; } } else { if (dynamicSiteInitializers == null) { dynamicSiteInitializers = ArrayBuilder <BoundExpression> .GetInstance(); } Debug.Assert(rewrittenLeft.Kind == BoundKind.DynamicObjectInitializerMember); var initializerMember = (BoundDynamicObjectInitializerMember)rewrittenLeft; if (!isRhsNestedInitializer) { var rewrittenRight = VisitExpression(assignment.Right); var setMember = dynamicFactory.MakeDynamicSetMember(rewrittenReceiver, initializerMember.MemberName, rewrittenRight); dynamicSiteInitializers.Add(setMember.SiteInitialization); result.Add(setMember.SiteInvocation); return; } var getMember = dynamicFactory.MakeDynamicGetMember(rewrittenReceiver, initializerMember.MemberName, resultIndexed: false); dynamicSiteInitializers.Add(getMember.SiteInitialization); rewrittenAccess = getMember.SiteInvocation; } AddObjectOrCollectionInitializers(ref dynamicSiteInitializers, result, rewrittenAccess, assignment.Right); }
// Rewrite object initializer member assignment and add it to the result. // new SomeType { Member = 0 }; // ~~~~~~~~~~ private void AddObjectInitializer( ref ArrayBuilder <BoundExpression> dynamicSiteInitializers, ref ArrayBuilder <LocalSymbol> temps, ArrayBuilder <BoundExpression> result, BoundExpression rewrittenReceiver, BoundAssignmentOperator assignment) { Debug.Assert(rewrittenReceiver != null); // Update the receiver for the field/property access as we might have introduced a temp for the initializer rewrite. BoundExpression rewrittenLeft = null; // Do not lower pointer access yet, we'll do it later. if (assignment.Left.Kind != BoundKind.PointerElementAccess) { rewrittenLeft = VisitExpression(assignment.Left); } BoundKind rhsKind = assignment.Right.Kind; bool isRhsNestedInitializer = rhsKind == BoundKind.ObjectInitializerExpression || rhsKind == BoundKind.CollectionInitializerExpression; BoundExpression rewrittenAccess; switch ((rewrittenLeft ?? assignment.Left).Kind) { case BoundKind.ObjectInitializerMember: { var memberInit = (BoundObjectInitializerMember)rewrittenLeft; if (!memberInit.Arguments.IsDefaultOrEmpty) { var args = EvaluateSideEffectingArgumentsToTemps( memberInit.Arguments, memberInit.MemberSymbol?.GetParameterRefKinds() ?? default(ImmutableArray <RefKind>), result, ref temps); memberInit = memberInit.Update( memberInit.MemberSymbol, args, memberInit.ArgumentNamesOpt, memberInit.ArgumentRefKindsOpt, memberInit.Expanded, memberInit.ArgsToParamsOpt, memberInit.ResultKind, memberInit.ReceiverType, memberInit.BinderOpt, memberInit.Type); } rewrittenAccess = MakeObjectInitializerMemberAccess(rewrittenReceiver, memberInit, isRhsNestedInitializer); if (!isRhsNestedInitializer) { // Rewrite simple assignment to field/property. var rewrittenRight = VisitExpression(assignment.Right); result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, false, assignment.Type, used: false)); return; } break; } case BoundKind.ArrayAccess: { var arrayAccess = (BoundArrayAccess)rewrittenLeft; var indices = EvaluateSideEffectingArgumentsToTemps( ImmutableArray.Create(arrayAccess.Index), paramRefKindsOpt: default, result, ref temps); rewrittenAccess = arrayAccess.Update(rewrittenReceiver, indices[0], arrayAccess.Type); if (!isRhsNestedInitializer) { // Rewrite simple assignment to field/property. var rewrittenRight = VisitExpression(assignment.Right); result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, false, assignment.Type, used: false)); return; } break; }
private static bool IsTupleExpression(BoundKind kind) { return(kind == BoundKind.TupleLiteral || kind == BoundKind.ConvertedTupleLiteral); }
protected BoundStatement(BoundKind kind, BoundTree boundTree, ImmutableArray <object> childBoundNodes, IOperation statement, LanguageSyntaxNode syntax, bool hasErrors = false) : base(kind, boundTree, childBoundNodes, syntax, hasErrors) { _statement = statement; }
public BoundSelectedEndPoint(BoundKind kind, BoundTree boundTree, ImmutableArray <object> childBoundNodes, LanguageSyntaxNode syntax, bool hasErrors) : base(kind, boundTree, childBoundNodes, syntax, hasErrors) { }
public BoundSymbolUse(BoundKind kind, BoundTree boundTree, ImmutableArray <object> childBoundNodes, ImmutableArray <Type> types, ImmutableArray <Type> nestingTypes, LanguageSyntaxNode syntax, bool hasErrors = false) : base(kind, boundTree, childBoundNodes, syntax, hasErrors) { _types = types; _nestingTypes = nestingTypes; }
protected BoundStatement(BoundKind kind, SyntaxNode syntax) : base(kind, syntax) { }
protected BoundExpression(BoundKind kind, BoundTree boundTree, ImmutableArray <object> childBoundNodes, IOperation expression, LanguageSyntaxNode syntax, bool hasErrors = false) : base(kind, boundTree, childBoundNodes, syntax, hasErrors) { _expression = expression; }
public BoundEnumValue(BoundKind kind, BoundTree boundTree, ImmutableArray <object> childBoundNodes, string name, Type enumType, LanguageSyntaxNode syntax, bool hasErrors = false) : base(kind, boundTree, childBoundNodes, syntax, hasErrors) { _name = name; _enumType = enumType; }
public BoundValue(BoundKind kind, BoundTree boundTree, ImmutableArray <object> childBoundNodes, object value, LanguageSyntaxNode syntax, bool hasErrors = false) : base(kind, boundTree, childBoundNodes, syntax, hasErrors) { _values = ImmutableArray.Create(value); }
public BoundSymbolDef(BoundKind kind, BoundTree boundTree, ImmutableArray <object> childBoundNodes, Type type, LanguageSyntaxNode syntax, bool hasErrors = false) : base(kind, boundTree, childBoundNodes, syntax, hasErrors) { _type = type; }
protected BoundNode(BoundKind kind, SyntaxNode syntax) { _kind = kind; Syntax = syntax; }
public BoundInfo (TypeSpec type, BoundKind kind) { this.Type = type; this.Kind = kind; }
public BoundInfo (TypeSpec type, BoundKind kind) { // Unify dynamic and object to simplify best candidate resolution if (type == InternalType.Dynamic) type = TypeManager.object_type; this.Type = type; this.Kind = kind; }
// Rewrite object initializer member assignment and add it to the result. // new SomeType { Member = 0 }; // ~~~~~~~~~~ private void AddObjectInitializer( ref ArrayBuilder <BoundExpression> dynamicSiteInitializers, ref ArrayBuilder <LocalSymbol> temps, ArrayBuilder <BoundExpression> result, BoundExpression rewrittenReceiver, BoundAssignmentOperator assignment) { Debug.Assert(rewrittenReceiver != null); Debug.Assert(!_inExpressionLambda); // Update the receiver for the field/property access as we might have introduced a temp for the initializer rewrite. BoundExpression rewrittenLeft = null; // Do not lower pointer access yet, we'll do it later. if (assignment.Left.Kind != BoundKind.PointerElementAccess) { rewrittenLeft = VisitExpression(assignment.Left); } BoundKind rhsKind = assignment.Right.Kind; bool isRhsNestedInitializer = rhsKind == BoundKind.ObjectInitializerExpression || rhsKind == BoundKind.CollectionInitializerExpression; BoundExpression rewrittenAccess; switch ((rewrittenLeft ?? assignment.Left).Kind) { case BoundKind.ObjectInitializerMember: { var memberInit = (BoundObjectInitializerMember)rewrittenLeft; if (!memberInit.Arguments.IsDefaultOrEmpty) { var args = EvaluateSideEffectingArgumentsToTemps(memberInit.Arguments, result, ref temps); memberInit = memberInit.Update( memberInit.MemberSymbol, args, memberInit.ArgumentNamesOpt, memberInit.ArgumentRefKindsOpt, memberInit.Expanded, memberInit.ArgsToParamsOpt, memberInit.ResultKind, memberInit.ReceiverType, memberInit.BinderOpt, memberInit.Type); } if (memberInit.MemberSymbol == null && memberInit.Type.IsDynamic()) { if (dynamicSiteInitializers == null) { dynamicSiteInitializers = ArrayBuilder <BoundExpression> .GetInstance(); } if (!isRhsNestedInitializer) { var rewrittenRight = VisitExpression(assignment.Right); var setMember = _dynamicFactory.MakeDynamicSetIndex( rewrittenReceiver, memberInit.Arguments, memberInit.ArgumentNamesOpt, memberInit.ArgumentRefKindsOpt, rewrittenRight); dynamicSiteInitializers.Add(setMember.SiteInitialization); result.Add(setMember.SiteInvocation); return; } var getMember = _dynamicFactory.MakeDynamicGetIndex( rewrittenReceiver, memberInit.Arguments, memberInit.ArgumentNamesOpt, memberInit.ArgumentRefKindsOpt); dynamicSiteInitializers.Add(getMember.SiteInitialization); rewrittenAccess = getMember.SiteInvocation; } else { rewrittenAccess = MakeObjectInitializerMemberAccess(rewrittenReceiver, memberInit, isRhsNestedInitializer); if (!isRhsNestedInitializer) { // Rewrite simple assignment to field/property. var rewrittenRight = VisitExpression(assignment.Right); result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, false, assignment.Type, used: false)); return; } } break; } case BoundKind.DynamicObjectInitializerMember: { if (dynamicSiteInitializers == null) { dynamicSiteInitializers = ArrayBuilder <BoundExpression> .GetInstance(); } var initializerMember = (BoundDynamicObjectInitializerMember)rewrittenLeft; if (!isRhsNestedInitializer) { var rewrittenRight = VisitExpression(assignment.Right); var setMember = _dynamicFactory.MakeDynamicSetMember(rewrittenReceiver, initializerMember.MemberName, rewrittenRight); dynamicSiteInitializers.Add(setMember.SiteInitialization); result.Add(setMember.SiteInvocation); return; } var getMember = _dynamicFactory.MakeDynamicGetMember(rewrittenReceiver, initializerMember.MemberName, resultIndexed: false); dynamicSiteInitializers.Add(getMember.SiteInitialization); rewrittenAccess = getMember.SiteInvocation; break; } case BoundKind.ArrayAccess: { var arrayAccess = (BoundArrayAccess)rewrittenLeft; var indices = EvaluateSideEffectingArgumentsToTemps(arrayAccess.Indices, result, ref temps); rewrittenAccess = arrayAccess.Update(rewrittenReceiver, indices, arrayAccess.Type); if (!isRhsNestedInitializer) { // Rewrite simple assignment to field/property. var rewrittenRight = VisitExpression(assignment.Right); result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, false, assignment.Type, used: false)); return; } break; } case BoundKind.PointerElementAccess: { // Remember we haven't lowered this node yet. var pointerAccess = (BoundPointerElementAccess)assignment.Left; var rewrittenIndex = VisitExpression(pointerAccess.Index); if (CanChangeValueBetweenReads(rewrittenIndex)) { BoundAssignmentOperator store; var temp = _factory.StoreToTemp(rewrittenIndex, out store); rewrittenIndex = temp; if (temps == null) { temps = ArrayBuilder <LocalSymbol> .GetInstance(); } temps.Add(temp.LocalSymbol); result.Add(store); } rewrittenAccess = RewritePointerElementAccess(pointerAccess, rewrittenReceiver, rewrittenIndex); if (!isRhsNestedInitializer) { // Rewrite as simple assignment. var rewrittenRight = VisitExpression(assignment.Right); result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, false, assignment.Type, used: false)); return; } break; } default: throw ExceptionUtilities.UnexpectedValue((rewrittenLeft ?? assignment.Left).Kind); } AddObjectOrCollectionInitializers(ref dynamicSiteInitializers, ref temps, result, rewrittenAccess, assignment.Right); }
public BoundIdentifier(BoundKind kind, BoundTree boundTree, ImmutableArray <object> childBoundNodes, LanguageSyntaxNode syntax, bool hasErrors = false) : base(kind, boundTree, childBoundNodes, syntax, hasErrors) { }
private void ReportMissingThis(BoundKind boundKind, CSharpSyntaxNode syntax) { Debug.Assert(boundKind == BoundKind.ThisReference || boundKind == BoundKind.BaseReference); var errorCode = boundKind == BoundKind.BaseReference ? ErrorCode.ERR_BaseInBadContext : ErrorCode.ERR_ThisInBadContext; _diagnostics.Add(new CSDiagnostic(new CSDiagnosticInfo(errorCode), syntax.Location)); }
public CustomBoundNode(BoundKind kind, BoundTree boundTree, ImmutableArray <object> childBoundNodes, LanguageSyntaxNode syntax, bool hasErrors) : base(kind, boundTree, childBoundNodes, syntax, hasErrors) { }
public BoundInfo(Type type, BoundKind kind) { Type = type; Kind = kind; }
protected BoundExpression(BoundKind kind, SyntaxNode syntax, TypeSymbol type) : base(kind, syntax) { this.Type = type; }
protected BoundStatementList(BoundKind kind, SyntaxNode syntax, ImmutableArray <BoundStatement> statements) : base(kind, syntax) { this.Statements = statements; }
public BoundAttribute(BoundKind kind, BoundTree boundTree, ImmutableArray <object> childBoundNodes, ImmutableArray <Type> types, ImmutableArray <Type> nestingTypes, LanguageSyntaxNode syntax, bool hasErrors = false) : base(kind, boundTree, childBoundNodes, types, nestingTypes, syntax, hasErrors) { }