public OAuthContext()
{
_consumerKey = new BoundParameter(Parameters.OAuth_Consumer_Key, this);
_nonce = new BoundParameter(Parameters.OAuth_Nonce, this);
_signature = new BoundParameter(Parameters.OAuth_Signature, this);
_signatureMethod = new BoundParameter(Parameters.OAuth_Signature_Method, this);
_timestamp = new BoundParameter(Parameters.OAuth_Timestamp, this);
_token = new BoundParameter(Parameters.OAuth_Token, this);
_tokenSecret = new BoundParameter(Parameters.OAuth_Token_Secret, this);
_version = new BoundParameter(Parameters.OAuth_Version, this);
_verifier = new BoundParameter(Parameters.OAuth_Verifier, this);
_callback = new BoundParameter(Parameters.OAuth_Callback, this);
FormEncodedParameters = new NameValueCollection();
Cookies = new NameValueCollection();
Headers = new NameValueCollection();
AuthorizationHeaderParameters = new NameValueCollection();
UseAuthorizationHeader = true;
}
public override BoundNode VisitParameter(BoundParameter node)
{
CapturedSymbolReplacement proxy;
if (proxies.TryGetValue(node.ParameterSymbol, out proxy))
{
return proxy.Replacement(node.Syntax, frameType => FramePointer(node.Syntax, frameType));
}
ParameterSymbol replacementParameter;
if (this.parameterMap.TryGetValue(node.ParameterSymbol, out replacementParameter))
{
return new BoundParameter(node.Syntax, replacementParameter, replacementParameter.Type, node.HasErrors);
}
return base.VisitParameter(node);
}
// private static T <Factory>(object[] submissionArray)
// {
// var submission = new Submission#N(submissionArray);
// return submission.<Initialize>();
// }
internal override BoundBlock CreateBody()
{
var syntax = this.GetSyntax();
var ctor = _containingType.GetScriptConstructor();
Debug.Assert(ctor.ParameterCount == 1);
var initializer = _containingType.GetScriptInitializer();
Debug.Assert(initializer.ParameterCount == 0);
var submissionArrayParameter = new BoundParameter(syntax, _parameters[0]) { WasCompilerGenerated = true };
var submissionLocal = new BoundLocal(
syntax,
new SynthesizedLocal(this, _containingType, SynthesizedLocalKind.LoweringTemp),
null,
_containingType)
{ WasCompilerGenerated = true };
// var submission = new Submission#N(submissionArray);
var submissionAssignment = new BoundExpressionStatement(
syntax,
new BoundAssignmentOperator(
syntax,
submissionLocal,
new BoundObjectCreationExpression(
syntax,
ctor,
ImmutableArray.Create<BoundExpression>(submissionArrayParameter),
default(ImmutableArray<string>),
default(ImmutableArray<RefKind>),
false,
default(ImmutableArray<int>),
null,
null,
_containingType)
{ WasCompilerGenerated = true },
_containingType)
{ WasCompilerGenerated = true })
{ WasCompilerGenerated = true };
// return submission.<Initialize>();
BoundExpression initializeResult = new BoundCall(
syntax,
submissionLocal,
initializer,
ImmutableArray<BoundExpression>.Empty,
default(ImmutableArray<string>),
default(ImmutableArray<RefKind>),
isDelegateCall: false,
expanded: false,
invokedAsExtensionMethod: false,
argsToParamsOpt: default(ImmutableArray<int>),
resultKind: LookupResultKind.Viable,
type: initializer.ReturnType)
{ WasCompilerGenerated = true };
if (initializeResult.Type.IsStructType() && (_returnType.SpecialType == SpecialType.System_Object))
{
initializeResult = new BoundConversion(syntax, initializeResult, Conversion.Boxing, false, true, ConstantValue.NotAvailable, _returnType)
{ WasCompilerGenerated = true };
}
var returnStatement = new BoundReturnStatement(
syntax,
initializeResult)
{ WasCompilerGenerated = true };
return new BoundBlock(syntax,
ImmutableArray.Create<LocalSymbol>(submissionLocal.LocalSymbol),
ImmutableArray.Create<BoundStatement>(submissionAssignment, returnStatement))
{ WasCompilerGenerated = true };
}
// Generates:
//
// private static T {Factory}(InteractiveSession session)
// {
// T submissionResult;
// new {ThisScriptClass}(session, out submissionResult);
// return submissionResult;
// }
private BoundBlock CreateSubmissionFactoryBody()
{
Debug.Assert(containingType.TypeKind == TypeKind.Submission);
SyntaxTree syntaxTree = CSharpSyntaxTree.Dummy;
CSharpSyntaxNode syntax = (CSharpSyntaxNode)syntaxTree.GetRoot();
var interactiveSessionParam = new BoundParameter(syntax, parameters[0])
{
WasCompilerGenerated = true
};
var ctor = containingType.InstanceConstructors.Single();
Debug.Assert(ctor is SynthesizedInstanceConstructor);
Debug.Assert(ctor.ParameterCount == 2);
var submissionResultType = ctor.Parameters[1].Type;
var resultLocal = new SynthesizedLocal(ctor, submissionResultType, SynthesizedLocalKind.LoweringTemp);
var localReference = new BoundLocal(syntax, resultLocal, null, submissionResultType)
{
WasCompilerGenerated = true
};
BoundExpression submissionResult = localReference;
if (submissionResultType.IsStructType() && this.returnType.SpecialType == SpecialType.System_Object)
{
submissionResult = new BoundConversion(syntax, submissionResult, Conversion.Boxing, false, true, ConstantValue.NotAvailable, this.returnType)
{
WasCompilerGenerated = true
};
}
return(new BoundBlock(syntax,
// T submissionResult;
ImmutableArray.Create <LocalSymbol>(resultLocal),
ImmutableArray.Create <BoundStatement>(
// new Submission(interactiveSession, out submissionResult);
new BoundExpressionStatement(syntax,
new BoundObjectCreationExpression(
syntax,
ctor,
ImmutableArray.Create <BoundExpression>(interactiveSessionParam, localReference),
ImmutableArray <string> .Empty,
ImmutableArray.Create <RefKind>(RefKind.None, RefKind.Ref),
false,
default(ImmutableArray <int>),
null,
null,
containingType
)
{
WasCompilerGenerated = true
})
{
WasCompilerGenerated = true
},
// return submissionResult;
new BoundReturnStatement(syntax, submissionResult)
{
WasCompilerGenerated = true
}))
{
WasCompilerGenerated = true
});
}
private void EmitParameterLoad(BoundParameter parameter)
{
int slot = ParameterSlot(parameter);
_builder.EmitLoadArgumentOpcode(slot);
if (parameter.ParameterSymbol.RefKind != RefKind.None)
{
var parameterType = parameter.ParameterSymbol.Type;
EmitLoadIndirect(parameterType, parameter.Syntax);
}
}
protected virtual BoundNode VisitUnhoistedParameter(BoundParameter node)
{
return base.VisitParameter(node);
}
private void EmitParameterAddress(BoundParameter parameter)
{
int slot = ParameterSlot(parameter);
if (parameter.ParameterSymbol.RefKind == RefKind.None)
{
builder.EmitLoadArgumentAddrOpcode(slot);
}
else
{
builder.EmitLoadArgumentOpcode(slot);
}
}
public override BoundNode VisitParameter(BoundParameter node)
{
return RewriteParameter(node.Syntax, node.ParameterSymbol, node);
}
protected virtual BoundNode VisitUnhoistedParameter(BoundParameter node)
{
return(base.VisitParameter(node));
}
static BoundStatement makeAppendString(SyntheticBoundNodeFactory F, BoundParameter builder, string value)
{
return(F.ExpressionStatement(F.Call(receiver: builder, F.WellKnownMethod(WellKnownMember.System_Text_StringBuilder__AppendString), F.StringLiteral(value))));
}
internal override void GenerateMethodBody(TypeCompilationState compilationState, BindingDiagnosticBag diagnostics)
{
var F = new SyntheticBoundNodeFactory(this, ContainingType.GetNonNullSyntaxNode(), compilationState, diagnostics);
try
{
ImmutableArray <Symbol> printableMembers = ContainingType.GetMembers().WhereAsArray(m => isPrintable(m));
if (ReturnType.IsErrorType() ||
printableMembers.Any(m => m.GetTypeOrReturnType().Type.IsErrorType()))
{
F.CloseMethod(F.ThrowNull());
return;
}
ArrayBuilder <BoundStatement> block;
BoundParameter builder = F.Parameter(this.Parameters[0]);
if (ContainingType.BaseTypeNoUseSiteDiagnostics.IsObjectType() || ContainingType.IsRecordStruct)
{
if (printableMembers.IsEmpty)
{
// return false;
F.CloseMethod(F.Return(F.Literal(false)));
return;
}
block = ArrayBuilder <BoundStatement> .GetInstance();
if (!ContainingType.IsRecordStruct)
{
var ensureStackMethod = F.WellKnownMethod(
WellKnownMember.System_Runtime_CompilerServices_RuntimeHelpers__EnsureSufficientExecutionStack,
isOptional: true);
if (ensureStackMethod is not null)
{
block.Add(F.ExpressionStatement(
F.Call(receiver: null, ensureStackMethod)));
}
}
}
else
{
MethodSymbol?basePrintMethod = OverriddenMethod;
if (basePrintMethod is null ||
basePrintMethod.ReturnType.SpecialType != SpecialType.System_Boolean)
{
F.CloseMethod(F.ThrowNull()); // an error was reported in base checks already
return;
}
var basePrintCall = F.Call(receiver: F.Base(ContainingType.BaseTypeNoUseSiteDiagnostics), basePrintMethod, builder);
if (printableMembers.IsEmpty)
{
// return base.PrintMembers(builder);
F.CloseMethod(F.Return(basePrintCall));
return;
}
else
{
block = ArrayBuilder <BoundStatement> .GetInstance();
// if (base.PrintMembers(builder))
// builder.Append(", ")
block.Add(F.If(basePrintCall, makeAppendString(F, builder, ", ")));
}
}
Debug.Assert(!printableMembers.IsEmpty);
for (var i = 0; i < printableMembers.Length; i++)
{
// builder.Append(", <name> = "); // if previous members exist
// builder.Append("<name> = "); // if it is the first member
// The only printable members are fields and properties,
// which cannot be generic so as to have variant names
var member = printableMembers[i];
var memberHeader = $"{member.Name} = ";
if (i > 0)
{
memberHeader = ", " + memberHeader;
}
block.Add(makeAppendString(F, builder, memberHeader));
var value = member.Kind switch
{
SymbolKind.Field => F.Field(F.This(), (FieldSymbol)member),
SymbolKind.Property => F.Property(F.This(), (PropertySymbol)member),
_ => throw ExceptionUtilities.UnexpectedValue(member.Kind)
};
// builder.Append((object)<value>); OR builder.Append(<value>.ToString()); for value types
Debug.Assert(value.Type is not null);
if (value.Type.IsValueType)
{
block.Add(F.ExpressionStatement(
F.Call(receiver: builder,
F.WellKnownMethod(WellKnownMember.System_Text_StringBuilder__AppendString),
F.Call(value, F.SpecialMethod(SpecialMember.System_Object__ToString)))));
}
else
{
block.Add(F.ExpressionStatement(
F.Call(receiver: builder,
F.WellKnownMethod(WellKnownMember.System_Text_StringBuilder__AppendObject),
F.Convert(F.SpecialType(SpecialType.System_Object), value))));
}
}
block.Add(F.Return(F.Literal(true)));
F.CloseMethod(F.Block(block.ToImmutableAndFree()));
}
catch (SyntheticBoundNodeFactory.MissingPredefinedMember ex)
{
diagnostics.Add(ex.Diagnostic);
F.CloseMethod(F.ThrowNull());
}
public void UpdateBound(BoundParameter bound)
{
}
public override BoundNode VisitParameter(BoundParameter node)
{
return(RewriteParameter(node.Syntax, node.ParameterSymbol, node));
}
internal override BoundBlock CreateBody(BindingDiagnosticBag diagnostics)
{
var syntax = DummySyntax();
var ctor = _containingType.GetScriptConstructor();
Debug.Assert(ctor.ParameterCount == 1);
var initializer = _containingType.GetScriptInitializer();
Debug.Assert(initializer.ParameterCount == 0);
var submissionArrayParameter = new BoundParameter(syntax, _parameters[0])
{
WasCompilerGenerated = true
};
var submissionLocal = new BoundLocal(
syntax,
new SynthesizedLocal(this, TypeWithAnnotations.Create(_containingType), SynthesizedLocalKind.LoweringTemp),
null,
_containingType)
{
WasCompilerGenerated = true
};
// var submission = new Submission#N(submissionArray);
var submissionAssignment = new BoundExpressionStatement(
syntax,
new BoundAssignmentOperator(
syntax,
submissionLocal,
new BoundObjectCreationExpression(
syntax,
ctor,
ImmutableArray.Create <BoundExpression>(submissionArrayParameter),
argumentNamesOpt: default(ImmutableArray <string>),
argumentRefKindsOpt: default(ImmutableArray <RefKind>),
expanded: false,
argsToParamsOpt: default(ImmutableArray <int>),
defaultArguments: default(BitVector),
constantValueOpt: null,
initializerExpressionOpt: null,
type: _containingType)
{
WasCompilerGenerated = true
},
_containingType)
{
WasCompilerGenerated = true
})
{
WasCompilerGenerated = true
};
// return submission.<Initialize>();
var initializeResult = CreateParameterlessCall(
syntax,
submissionLocal,
initializer);
Debug.Assert(TypeSymbol.Equals(initializeResult.Type, _returnType.Type, TypeCompareKind.ConsiderEverything2));
var returnStatement = new BoundReturnStatement(
syntax,
RefKind.None,
initializeResult)
{
WasCompilerGenerated = true
};
return(new BoundBlock(syntax,
ImmutableArray.Create <LocalSymbol>(submissionLocal.LocalSymbol),
ImmutableArray.Create <BoundStatement>(submissionAssignment, returnStatement))
{
WasCompilerGenerated = true
});
}
// private static T <Factory>(object[] submissionArray)
// {
// var submission = new Submission#N(submissionArray);
// return submission.<Initialize>();
// }
internal override BoundBlock CreateBody()
{
var syntax = this.GetSyntax();
var ctor = _containingType.GetScriptConstructor();
Debug.Assert(ctor.ParameterCount == 1);
var initializer = _containingType.GetScriptInitializer();
Debug.Assert(initializer.ParameterCount == 0);
var submissionArrayParameter = new BoundParameter(syntax, _parameters[0])
{
WasCompilerGenerated = true
};
var submissionLocal = new BoundLocal(
syntax,
new SynthesizedLocal(this, _containingType, SynthesizedLocalKind.LoweringTemp),
null,
_containingType)
{
WasCompilerGenerated = true
};
// var submission = new Submission#N(submissionArray);
var submissionAssignment = new BoundExpressionStatement(
syntax,
new BoundAssignmentOperator(
syntax,
submissionLocal,
new BoundObjectCreationExpression(
syntax,
ctor,
ImmutableArray.Create <BoundExpression>(submissionArrayParameter),
default(ImmutableArray <string>),
default(ImmutableArray <RefKind>),
false,
default(ImmutableArray <int>),
null,
null,
_containingType)
{
WasCompilerGenerated = true
},
_containingType)
{
WasCompilerGenerated = true
})
{
WasCompilerGenerated = true
};
// return submission.<Initialize>();
BoundExpression initializeResult = new BoundCall(
syntax,
submissionLocal,
initializer,
ImmutableArray <BoundExpression> .Empty,
default(ImmutableArray <string>),
default(ImmutableArray <RefKind>),
isDelegateCall: false,
expanded: false,
invokedAsExtensionMethod: false,
argsToParamsOpt: default(ImmutableArray <int>),
resultKind: LookupResultKind.Viable,
type: initializer.ReturnType)
{
WasCompilerGenerated = true
};
if (initializeResult.Type.IsStructType() && (_returnType.SpecialType == SpecialType.System_Object))
{
initializeResult = new BoundConversion(syntax, initializeResult, Conversion.Boxing, false, true, ConstantValue.NotAvailable, _returnType)
{
WasCompilerGenerated = true
};
}
var returnStatement = new BoundReturnStatement(
syntax,
initializeResult)
{
WasCompilerGenerated = true
};
return(new BoundBlock(syntax,
ImmutableArray.Create <LocalSymbol>(submissionLocal.LocalSymbol),
ImmutableArray.Create <BoundStatement>(submissionAssignment, returnStatement))
{
WasCompilerGenerated = true
});
}
public override BoundNode VisitParameter(BoundParameter node)
{
AddIfCaptured(node.ParameterSymbol, node.Syntax);
return(base.VisitParameter(node));
}
// private static T <Factory>(object[] submissionArray)
// {
// var submission = new Submission#N(submissionArray);
// return submission.<Initialize>();
// }
internal override BoundBlock CreateBody()
{
var syntax = this.GetSyntax();
var ctor = _containingType.GetScriptConstructor();
Debug.Assert(ctor.ParameterCount == 1);
var initializer = _containingType.GetScriptInitializer();
Debug.Assert(initializer.ParameterCount == 0);
var submissionArrayParameter = new BoundParameter(syntax, _parameters[0]) { WasCompilerGenerated = true };
var submissionLocal = new BoundLocal(
syntax,
new SynthesizedLocal(this, _containingType, SynthesizedLocalKind.LoweringTemp),
null,
_containingType)
{ WasCompilerGenerated = true };
// var submission = new Submission#N(submissionArray);
var submissionAssignment = new BoundExpressionStatement(
syntax,
new BoundAssignmentOperator(
syntax,
submissionLocal,
new BoundObjectCreationExpression(
syntax,
ctor,
ImmutableArray.Create<BoundExpression>(submissionArrayParameter),
default(ImmutableArray<string>),
default(ImmutableArray<RefKind>),
false,
default(ImmutableArray<int>),
null,
null,
_containingType)
{ WasCompilerGenerated = true },
_containingType)
{ WasCompilerGenerated = true })
{ WasCompilerGenerated = true };
// return submission.<Initialize>();
var initializeResult = CreateParameterlessCall(
syntax,
submissionLocal,
initializer);
Debug.Assert(initializeResult.Type == _returnType);
var returnStatement = new BoundReturnStatement(
syntax,
RefKind.None,
initializeResult)
{ WasCompilerGenerated = true };
return new BoundBlock(syntax,
ImmutableArray.Create<LocalSymbol>(submissionLocal.LocalSymbol),
ImmutableArray<LocalFunctionSymbol>.Empty,
ImmutableArray.Create<BoundStatement>(submissionAssignment, returnStatement))
{ WasCompilerGenerated = true };
}
// private static T <Factory>(object[] submissionArray)
// {
// var submission = new Submission#N(submissionArray);
// return submission.<Initialize>();
// }
internal override BoundBlock CreateBody(DiagnosticBag diagnostics)
{
var syntax = DummySyntax();
var ctor = _containingType.GetScriptConstructor();
Debug.Assert(ctor.ParameterCount == 1);
var initializer = _containingType.GetScriptInitializer();
Debug.Assert(initializer.ParameterCount == 0);
var submissionArrayParameter = new BoundParameter(syntax, _parameters[0])
{
WasCompilerGenerated = true
};
var submissionLocal = new BoundLocal(
syntax,
new SynthesizedLocal(this, TypeSymbolWithAnnotations.Create(_containingType), SynthesizedLocalKind.LoweringTemp),
null,
_containingType)
{
WasCompilerGenerated = true
};
// var submission = new Submission#N(submissionArray);
var submissionAssignment = new BoundExpressionStatement(
syntax,
new BoundAssignmentOperator(
syntax,
submissionLocal,
new BoundObjectCreationExpression(
syntax,
ctor,
ImmutableArray.Create <BoundExpression>(submissionArrayParameter),
default(ImmutableArray <string>),
default(ImmutableArray <RefKind>),
false,
default(ImmutableArray <int>),
null,
null,
null,
_containingType)
{
WasCompilerGenerated = true
},
_containingType)
{
WasCompilerGenerated = true
})
{
WasCompilerGenerated = true
};
// return submission.<Initialize>();
var initializeResult = CreateParameterlessCall(
syntax,
submissionLocal,
initializer);
Debug.Assert(initializeResult.Type == _returnType.TypeSymbol);
var returnStatement = new BoundReturnStatement(
syntax,
RefKind.None,
initializeResult)
{
WasCompilerGenerated = true
};
return(new BoundBlock(syntax,
ImmutableArray.Create <LocalSymbol>(submissionLocal.LocalSymbol),
ImmutableArray.Create <BoundStatement>(submissionAssignment, returnStatement))
{
WasCompilerGenerated = true
});
}
private EEMethodSymbol GetParameterMethod(EENamedTypeSymbol container, string methodName, string parameterName, int parameterIndex)
{
var syntax = SyntaxFactory.IdentifierName(parameterName);
return this.CreateMethod(container, methodName, syntax, (method, diagnostics) =>
{
var parameter = method.Parameters[parameterIndex];
var expression = new BoundParameter(syntax, parameter);
return new BoundReturnStatement(syntax, expression) { WasCompilerGenerated = true };
});
}
// Generates:
//
// private static T {Factory}(InteractiveSession session)
// {
// T submissionResult;
// new {ThisScriptClass}(session, out submissionResult);
// return submissionResult;
// }
private BoundBlock CreateSubmissionFactoryBody()
{
Debug.Assert(_containingType.TypeKind == TypeKind.Submission);
SyntaxTree syntaxTree = CSharpSyntaxTree.Dummy;
CSharpSyntaxNode syntax = (CSharpSyntaxNode)syntaxTree.GetRoot();
var interactiveSessionParam = new BoundParameter(syntax, _parameters[0]) { WasCompilerGenerated = true };
var ctor = _containingType.InstanceConstructors.Single();
Debug.Assert(ctor is SynthesizedInstanceConstructor);
Debug.Assert(ctor.ParameterCount == 2);
var submissionResultType = ctor.Parameters[1].Type;
var resultLocal = new SynthesizedLocal(ctor, submissionResultType, SynthesizedLocalKind.LoweringTemp);
var localReference = new BoundLocal(syntax, resultLocal, null, submissionResultType) { WasCompilerGenerated = true };
BoundExpression submissionResult = localReference;
if (submissionResultType.IsStructType() && _returnType.SpecialType == SpecialType.System_Object)
{
submissionResult = new BoundConversion(syntax, submissionResult, Conversion.Boxing, false, true, ConstantValue.NotAvailable, _returnType)
{ WasCompilerGenerated = true };
}
return new BoundBlock(syntax,
// T submissionResult;
ImmutableArray.Create<LocalSymbol>(resultLocal),
ImmutableArray.Create<BoundStatement>(
// new Submission(interactiveSession, out submissionResult);
new BoundExpressionStatement(syntax,
new BoundObjectCreationExpression(
syntax,
ctor,
ImmutableArray.Create<BoundExpression>(interactiveSessionParam, localReference),
ImmutableArray<string>.Empty,
ImmutableArray.Create<RefKind>(RefKind.None, RefKind.Ref),
false,
default(ImmutableArray<int>),
null,
null,
_containingType
)
{ WasCompilerGenerated = true })
{ WasCompilerGenerated = true },
// return submissionResult;
new BoundReturnStatement(syntax, submissionResult) { WasCompilerGenerated = true }))
{ WasCompilerGenerated = true };
}
public sealed override BoundNode VisitParameter(BoundParameter node)
{
BoundNode replacement;
if (TryReplaceWithProxy(node.ParameterSymbol, node.Syntax, out replacement))
{
return replacement;
}
// Non-captured and expression tree lambda parameters don't have a proxy.
return VisitUnhoistedParameter(node);
}
private EEMethodSymbol GetParameterMethod(EENamedTypeSymbol container, string methodName, string parameterName, int parameterIndex)
{
var syntax = SyntaxFactory.IdentifierName(parameterName);
return this.CreateMethod(container, methodName, syntax, (EEMethodSymbol method, DiagnosticBag diagnostics, out ImmutableArray<LocalSymbol> declaredLocals) =>
{
declaredLocals = ImmutableArray<LocalSymbol>.Empty;
var parameter = method.Parameters[parameterIndex];
var expression = new BoundParameter(syntax, parameter);
return new BoundReturnStatement(syntax, RefKind.None, expression) { WasCompilerGenerated = true };
});
}
private static int ParameterSlot(BoundParameter parameter)
{
var sym = parameter.ParameterSymbol;
int slot = sym.Ordinal;
if (!sym.ContainingSymbol.IsStatic)
{
slot++; // skip "this"
}
return slot;
}
// Generates:
//
// private static T {Factory}(InteractiveSession session)
// {
// T submissionResult;
// new {ThisScriptClass}(session, out submissionResult);
// return submissionResult;
// }
private BoundBlock CreateSubmissionFactoryBody()
{
Debug.Assert(containingType.TypeKind == TypeKind.Submission);
SyntaxTree syntaxTree = CSharpSyntaxTree.Dummy;
CSharpSyntaxNode syntax = (CSharpSyntaxNode)syntaxTree.GetRoot();
var interactiveSessionParam = new BoundParameter(syntax, parameters[0]) { WasCompilerGenerated = true };
var ctor = containingType.InstanceConstructors.Single();
Debug.Assert(ctor is SynthesizedInstanceConstructor);
Debug.Assert(ctor.ParameterCount == 2);
var submissionResultType = ctor.Parameters[1].Type;
var submissionResult = new BoundLocal(syntax, new SynthesizedLocal(ctor, submissionResultType), null, submissionResultType) { WasCompilerGenerated = true };
return new BoundBlock(syntax,
// T submissionResult;
ImmutableArray.Create<LocalSymbol>(submissionResult.LocalSymbol),
ImmutableArray.Create<BoundStatement>(
// new Submission(interactiveSession, out submissionResult);
new BoundExpressionStatement(syntax,
new BoundObjectCreationExpression(
syntax,
ctor,
ImmutableArray.Create<BoundExpression>(interactiveSessionParam, submissionResult),
ImmutableArray<string>.Empty,
ImmutableArray.Create<RefKind>(RefKind.None, RefKind.Ref),
false,
default(ImmutableArray<int>),
null,
null,
containingType
)
{ WasCompilerGenerated = true })
{ WasCompilerGenerated = true },
// return submissionResult;
new BoundReturnStatement(syntax, submissionResult) { WasCompilerGenerated = true }))
{ WasCompilerGenerated = true };
}
private void EmitParameterStore(BoundParameter parameter)
{
int slot = ParameterSlot(parameter);
if (parameter.ParameterSymbol.RefKind == RefKind.None)
{
_builder.EmitStoreArgumentOpcode(slot);
}
else
{
//NOTE: we should have the actual parameter already loaded,
//now need to do a store to where it points to
EmitIndirectStore(parameter.ParameterSymbol.Type, parameter.Syntax);
}
}
public override object VisitParameter(BoundParameter node, object arg)
{
CheckAssigned(node.ParameterSymbol, node.Syntax);
return(null);
}
