/// <summary>
/// Reports time-step number and physical time
/// </summary>
/// <returns></returns>
public override string ToString()
{
return(String.Format(
" {{ Time-step: {0}; Physical time: {1}s; Fields: {2}; Name: {3} }}",
TimeStepNumber.ToString(),
PhysicalTime,
FieldInitializers.Select(f => f.Identification).Aggregate((s, t) => s + ", " + t),
Name));
}
public void ExtendTypeInfoInitializer(FieldInitializers initializer, TypeReference typeReference)
{
}
public void ExtendMethodInfoInitializer(FieldInitializers initializers, MethodReference methodReference, bool isGeneric)
{
}
public void ExtendTypeInfoInitializer(FieldInitializers initializer, TypeReference typeReference)
{
}
public void ExtendMethodInfoInitializer(FieldInitializers initializers, MethodReference methodReference, bool isGeneric)
{
}
/// <summary>
/// In script C#, some field initializers are assignments to fields and others are global
/// statements. There are no restrictions on accessing instance members.
/// </summary>
private static void BindScriptFieldInitializers(CSharpCompilation compilation, MethodSymbol scriptCtor,
ImmutableArray <FieldInitializers> initializers, ArrayBuilder <BoundInitializer> boundInitializers, DiagnosticBag diagnostics,
bool generateDebugInfo, out ConsList <Imports> firstDebugImports)
{
Debug.Assert((object)scriptCtor != null);
firstDebugImports = null;
for (int i = 0; i < initializers.Length; i++)
{
FieldInitializers siblingInitializers = initializers[i];
// All sibling initializers share the same parent node and tree so we can reuse the binder
// factory across siblings. Unfortunately, we cannot reuse the binder itself, because
// individual fields might have their own binders (e.g. because of being declared unsafe).
BinderFactory binderFactory = null;
for (int j = 0; j < siblingInitializers.Initializers.Length; j++)
{
Debug.Assert(siblingInitializers.TypeDeclarationSyntax == null);
var initializer = siblingInitializers.Initializers[j];
var fieldSymbol = initializer.Field;
if ((object)fieldSymbol != null && fieldSymbol.IsConst)
{
// Constants do not need field initializers.
continue;
}
var syntaxRef = initializer.Syntax;
Debug.Assert(syntaxRef.SyntaxTree.Options.Kind != SourceCodeKind.Regular);
var initializerNode = (CSharpSyntaxNode)syntaxRef.GetSyntax();
if (binderFactory == null)
{
binderFactory = compilation.GetBinderFactory(syntaxRef.SyntaxTree);
}
Binder scriptClassBinder = binderFactory.GetBinder(initializerNode);
Debug.Assert(((ImplicitNamedTypeSymbol)scriptClassBinder.ContainingMemberOrLambda).IsScriptClass);
if (generateDebugInfo && firstDebugImports == null)
{
firstDebugImports = scriptClassBinder.ImportsList;
}
Binder parentBinder = new ExecutableCodeBinder((CSharpSyntaxNode)syntaxRef.SyntaxTree.GetRoot(), scriptCtor, scriptClassBinder);
BoundInitializer boundInitializer;
if ((object)fieldSymbol != null)
{
boundInitializer = BindFieldInitializer(
new LocalScopeBinder(parentBinder).WithAdditionalFlagsAndContainingMemberOrLambda(parentBinder.Flags | BinderFlags.FieldInitializer, fieldSymbol),
fieldSymbol,
(EqualsValueClauseSyntax)initializerNode,
diagnostics);
}
else if (initializerNode.Kind == SyntaxKind.LabeledStatement)
{
// TODO: labels in interactive
var boundStatement = new BoundBadStatement(initializerNode, ImmutableArray <BoundNode> .Empty, true);
boundInitializer = new BoundGlobalStatementInitializer(initializerNode, boundStatement);
}
else
{
var collisionDetector = new LocalScopeBinder(parentBinder);
boundInitializer = BindGlobalStatement(collisionDetector, (StatementSyntax)initializerNode, diagnostics,
isLast: i == initializers.Length - 1 && j == siblingInitializers.Initializers.Length - 1);
}
boundInitializers.Add(boundInitializer);
}
}
}
internal static ImmutableArray <LocalSymbol> GetFieldInitializerInfos(
CSharpCompilation compilation,
FieldInitializers siblingInitializers,
ArrayBuilder <FieldInitializerInfo> infos,
bool generateDebugInfo,
ref ConsList <Imports> firstDebugImports)
{
// All sibling initializers share the same parent node and tree so we can reuse the binder
// factory across siblings. Unfortunately, we cannot reuse the binder itself, because
// individual fields might have their own binders (e.g. because of being declared unsafe).
BinderFactory binderFactory = null;
foreach (FieldInitializer initializer in siblingInitializers.Initializers)
{
FieldSymbol fieldSymbol = initializer.Field;
Debug.Assert((object)fieldSymbol != null);
// A constant field of type decimal needs a field initializer, so
// check if it is a metadata constant, not just a constant to exclude
// decimals. Other constants do not need field initializers.
if (!fieldSymbol.IsMetadataConstant)
{
//Can't assert that this is a regular C# compilation, because we could be in a nested type of a script class.
SyntaxReference syntaxRef = initializer.Syntax;
var initializerNode = (EqualsValueClauseSyntax)syntaxRef.GetSyntax();
if (binderFactory == null)
{
binderFactory = compilation.GetBinderFactory(syntaxRef.SyntaxTree);
}
Binder parentBinder = binderFactory.GetBinder(initializerNode);
Debug.Assert(parentBinder.ContainingMemberOrLambda == fieldSymbol.ContainingType || //should be the binder for the type
fieldSymbol.ContainingType.IsImplicitClass); //however, we also allow fields in namespaces to help support script scenarios
if (generateDebugInfo && firstDebugImports == null)
{
firstDebugImports = parentBinder.ImportsList;
}
parentBinder = new LocalScopeBinder(parentBinder).WithAdditionalFlagsAndContainingMemberOrLambda(parentBinder.Flags | BinderFlags.FieldInitializer, fieldSymbol);
if (!fieldSymbol.IsConst && !fieldSymbol.IsStatic)
{
parentBinder = parentBinder.WithPrimaryConstructorParametersIfNecessary(fieldSymbol.ContainingType);
}
infos.Add(new FieldInitializerInfo(initializer, parentBinder, initializerNode));
}
}
// See if there are locals that we need to bring into the scope.
var locals = default(ImmutableArray <LocalSymbol>);
if (siblingInitializers.TypeDeclarationSyntax != null)
{
locals = GetInitializationScopeLocals(infos);
if (!locals.IsDefaultOrEmpty)
{
for (int i = 0; i < infos.Count; i++)
{
FieldInitializerInfo info = infos[i];
// Constant initializers is not part of the initialization scope.
if (!info.Initializer.Field.IsConst)
{
infos[i] = new FieldInitializerInfo(info.Initializer,
new SimpleLocalScopeBinder(locals, info.Binder),
info.EqualsValue);
}
}
}
}
return(locals);
}
public void ExtendTypeInfoInitializer(FieldInitializers initializer, TypeReference typeReference)
{
initializer.Add("debug_info", "&" + Naming.ForDebugTypeInfos(typeReference));
}
public void ExtendMethodInfoInitializer(FieldInitializers initializers, MethodReference methodReference, bool isGeneric)
{
initializers.Add("debug_info", !isGeneric ? ("&" + Naming.ForDebugMethodInfo(methodReference)) : "0");
}
