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)
{
}
