override public void LeaveMethod(Method node)
{
InternalMethod derived = (InternalMethod)node.Entity;
IMethod super = derived.Overriden;
if (null != super)
{
TypeMemberModifiers derivedAccess = TypeSystemServices.GetAccess(derived);
TypeMemberModifiers superAccess = TypeSystemServices.GetAccess(super);
if (derivedAccess < superAccess)
{
Error(CompilerErrorFactory.DerivedMethodCannotReduceAccess(
node,
derived,
super,
derivedAccess,
superAccess));
}
}
CheckUnusedLocals(node);
CheckAbstractMethodCantHaveBody(node);
CheckValidExtension(node);
CheckNotFinalizer(node);
CheckImplicitReturn(node);
CheckAmbiguousVariableNames(node);
}
protected MethodToStateMachineTransformer(CompilerContext context, InternalMethod method)
{
_labels = new List <LabelStatement>();
_method = method;
Initialize(context);
}
override public void OnMethod(Method node)
{
_currentMethod = (InternalMethod)node.Entity;
_state.Reset();
Visit(node.Body);
ResolveLabelReferences();
}
IType GetExtendedMacroType(IMethod method)
{
InternalMethod internalMethod = method as InternalMethod;
if (null != internalMethod)
{
Method extension = internalMethod.Method;
if (!extension.Attributes.Contains(Types.CompilerGeneratedAttribute.FullName))
{
return(null);
}
SimpleTypeReference sref = extension.Parameters[0].Type as SimpleTypeReference;
if (null != sref && extension.Parameters.Count == 2)
{
IType type = NameResolutionService.ResolveQualifiedName(sref.Name) as IType;
if (type != null && type.Name.EndsWith("Macro")) //no entity yet
{
return(type);
}
}
}
else if (method is ExternalMethod && method.IsExtension)
{
var parameters = method.GetParameters();
if (parameters.Length == 2 && TypeSystemServices.IsMacro(parameters[0].Type))
{
return(parameters[0].Type);
}
}
return(null);
}
BooClassBuilder CreateClosureClass(ForeignReferenceCollector collector, InternalMethod closure)
{
Method method = closure.Method;
TypeDefinition parent = method.DeclaringType;
parent.Members.Remove(method);
BooClassBuilder builder = collector.CreateSkeletonClass(closure.Name, method.LexicalInfo);
parent.Members.Add(builder.ClassDefinition);
builder.ClassDefinition.Members.Add(method);
method.Name = "Invoke";
if (method.IsStatic)
{
// need to adjust paremeter indexes (parameter 0 is now self)
foreach (ParameterDeclaration parameter in method.Parameters)
{
((InternalParameter)parameter.Entity).Index += 1;
}
}
method.Modifiers = TypeMemberModifiers.Public;
var coll = new GenericTypeCollector(CodeBuilder);
coll.Process(builder.ClassDefinition);
return(builder);
}
override public void LeaveBlockExpression(BlockExpression node)
{
InternalMethod closureEntity = (InternalMethod)GetEntity(node);
using (ForeignReferenceCollector collector = new ForeignReferenceCollector())
{
collector.CurrentMethod = closureEntity.Method;
collector.CurrentType = (IType)closureEntity.DeclaringType;
collector.Initialize(_context);
collector.Visit(closureEntity.Method.Body);
if (collector.ContainsForeignLocalReferences)
{
BooClassBuilder closureClass = CreateClosureClass(collector, closureEntity);
collector.AdjustReferences();
ReplaceCurrentNode(
CodeBuilder.CreateMemberReference(
collector.CreateConstructorInvocationWithReferencedEntities(
closureClass.Entity),
closureEntity));
}
else
{
Expression expression = CodeBuilder.CreateMemberReference(closureEntity);
TypeSystemServices.GetConcreteExpressionType(expression);
ReplaceCurrentNode(expression);
}
}
}
public GeneratorMethodProcessor(CompilerContext context, InternalMethod method)
{
_labels = new List();
_mapping = new Hashtable();
_generator = method;
Initialize(context);
}
internal AsyncMethodProcessor(
CompilerContext context,
InternalMethod method)
: base(context, method)
{
_awaiterFields = new Dictionary <IType, Field>();
_nextAwaiterId = 0;
}
override public void LeaveMethod(Method method)
{
InternalMethod entity = (InternalMethod)method.Entity;
if (entity.IsGenerator)
{
GeneratorMethodProcessor processor = new GeneratorMethodProcessor(_context, entity);
processor.Run();
}
}
public GeneratorMethodProcessor(CompilerContext context, InternalMethod method)
: base(context, method)
{
var skeleton = My <GeneratorSkeletonBuilder> .Instance.SkeletonFor(method);
_generatorItemType = skeleton.GeneratorItemType;
_enumerable = skeleton.GeneratorClassBuilder;
_getEnumeratorBuilder = skeleton.GetEnumeratorBuilder;
_methodToEnumerableMapper = skeleton.GeneratorClassTypeReplacer;
}
public GeneratorMethodProcessor(CompilerContext context, InternalMethod method)
{
_labels = new List();
_mapping = new Hashtable();
_generator = method;
_generatorItemType = (IType)_generator.Method["GeneratorItemType"];
_enumerable = (BooClassBuilder)_generator.Method["GeneratorClassBuilder"];
Debug.Assert(null != _generatorItemType);
Debug.Assert(null != _enumerable);
Initialize(context);
}
public override void OnMethod(Method node)
{
if (EvalAnnotation.IsMarked(node))
{
this._currentMethod = (InternalMethod)this.GetEntity(node);
IType evaluationContextType = this.DefineEvaluationContext();
Block stmt = this.PrepareEvaluationContextInitialization(evaluationContextType);
this.Visit(node.Body);
node.Body.Insert(0, stmt);
}
}
public bool IsEmptyCoroutine(Method node)
{
InternalMethod entity = (InternalMethod)this.GetEntity(node);
bool flag1 = entity.ReturnType == this.GetGeneratorReturnType(entity);
if (!flag1)
{
return(flag1);
}
return(this.HasNeitherReturnNorYield(node));
}
IType InferGeneratorItemTypeFor(InternalMethod generator)
{
if (TypeSystemServices.IsGenericGeneratorReturnType(generator.ReturnType))
{
return(generator.ReturnType.ConstructedInfo.GenericArguments[0]);
}
var yieldExpressions = generator.YieldExpressions;
return(yieldExpressions.Count > 0
? TypeSystemServices.GetMostGenericType(yieldExpressions)
: TypeSystemServices.ObjectType);
}
public GeneratorMethodProcessor(CompilerContext context, InternalMethod method)
{
_labels = new List <LabelStatement>();
_mapping = new Hashtable();
_generator = method;
GeneratorSkeleton skeleton = My <GeneratorSkeletonBuilder> .Instance.SkeletonFor(method);
_generatorItemType = skeleton.GeneratorItemType;
_enumerable = skeleton.GeneratorClassBuilder;
_getEnumeratorBuilder = skeleton.GetEnumeratorBuilder;
Initialize(context);
}
void CreateMoveNext()
{
Method generator = _generator.Method;
BooMethodBuilder methodBuilder = _enumerator.AddVirtualMethod("MoveNext", TypeSystemServices.BoolType);
methodBuilder.Method.LexicalInfo = generator.LexicalInfo;
_moveNext = methodBuilder.Entity;
TransformLocalsIntoFields(generator);
TransformParametersIntoFieldsInitializedByConstructor(generator);
methodBuilder.Body.Add(CreateLabel(generator));
// Visit() needs to know the number of the finished state
_finishedStateNumber = _labels.Count;
LabelStatement finishedLabel = CreateLabel(generator);
methodBuilder.Body.Add(generator.Body);
generator.Body.Clear();
Visit(methodBuilder.Body);
methodBuilder.Body.Add(CreateYieldInvocation(LexicalInfo.Empty, _finishedStateNumber, null));
methodBuilder.Body.Add(finishedLabel);
methodBuilder.Body.Insert(0,
CodeBuilder.CreateSwitch(
this.LexicalInfo,
CodeBuilder.CreateMemberReference(_state),
_labels));
// if the method contains converted try statements, put it in a try/failure block
if (_convertedTryStatements.Count > 0)
{
IMethod dispose = CreateDisposeMethod();
var tryFailure = new TryStatement();
tryFailure.ProtectedBlock.Add(methodBuilder.Body);
tryFailure.FailureBlock = new Block();
tryFailure.FailureBlock.Add(CallMethodOnSelf(dispose));
methodBuilder.Body.Clear();
methodBuilder.Body.Add(tryFailure);
}
}
void CreateMoveNext()
{
Method generator = _generator.Method;
BooMethodBuilder mn = _enumerator.AddVirtualMethod("MoveNext", TypeSystemServices.BoolType);
mn.Method.LexicalInfo = this.LexicalInfo;
_moveNext = mn.Entity;
foreach (Local local in generator.Locals)
{
InternalLocal entity = (InternalLocal)local.Entity;
Field field = _enumerator.AddField("___" + entity.Name + _context.AllocIndex(), entity.Type);
field.Modifiers |= TypeMemberModifiers.Internal;
_mapping[entity] = field.Entity;
}
generator.Locals.Clear();
foreach (ParameterDeclaration parameter in generator.Parameters)
{
InternalParameter entity = (InternalParameter)parameter.Entity;
if (entity.IsUsed)
{
Field field = DeclareFieldInitializedFromConstructorParameter(_enumerator, _enumeratorConstructor,
entity.Name,
entity.Type);
_mapping[entity] = field.Entity;
}
}
mn.Body.Add(CreateLabel(generator));
mn.Body.Add(generator.Body);
generator.Body.Clear();
Visit(mn.Body);
mn.Body.Add(CreateYieldInvocation(null));
mn.Body.Add(CreateLabel(generator));
mn.Body.Insert(0,
CodeBuilder.CreateSwitch(
this.LexicalInfo,
CodeBuilder.CreateMemberReference(_state),
_labels));
}
override public void LeaveMethod(Method node)
{
InternalMethod derived = (InternalMethod)node.Entity;
IMethod super = derived.Overriden;
if (null != super)
{
TypeMemberModifiers derivedAccess = TypeSystemServices.GetAccess(derived);
TypeMemberModifiers superAccess = TypeSystemServices.GetAccess(super);
if (derivedAccess < superAccess)
{
Error(CompilerErrorFactory.DerivedMethodCannotReduceAccess(
node,
derived.FullName,
super.FullName,
derivedAccess,
superAccess));
}
}
CheckUnusedLocals(node);
CheckAbstractMethodCantHaveBody(node);
}
IType GetExtensionMacroType(IMethod method)
{
InternalMethod internalMethod = method as InternalMethod;
if (null != internalMethod)
{
Method extension = internalMethod.Method;
SimpleTypeReference sref = extension.ReturnType as SimpleTypeReference;
if (null != sref)
{
IType type = NameResolutionService.ResolveQualifiedName(sref.Name) as IType;
if (type != null && type.Name.EndsWith("Macro")) //no entity yet
{
return(type);
}
}
}
else if (method is ExternalMethod)
{
return(method.ReturnType);
}
return(null);
}
public override IType GetGeneratorReturnType(InternalMethod generator) => this.TypeSystemServices.IEnumeratorType;
public virtual IType GeneratorItemTypeFor(InternalMethod generator)
{
return(TypeSystemServices.MapWildcardType(InferGeneratorItemTypeFor(generator)));
}
public GeneratorSkeleton SkeletonFor(InternalMethod generator)
{
Method enclosingMethod = generator.Method;
return(CreateGeneratorSkeleton(enclosingMethod, enclosingMethod, GeneratorItemTypeFor(generator)));
}
protected virtual IType GeneratorItemTypeFor(InternalMethod generator)
{
return(_generatorItemTypeInferrer.Instance.GeneratorItemTypeFor(generator));
}
private static void SendInternalRpc(CSteamID friendSteamId, InternalMethod intMethod, object[] data = null)
{
byte[] bytes = netvrkSerialization.SerializeInternal((byte)intMethod, data);
SteamNetworking.SendP2PPacket(friendSteamId, bytes, (uint)bytes.Length, EP2PSend.k_EP2PSendReliable, 0);
}
private static void InternalExecute(IStore store, BSonDoc command, InternalMethod method)
{
if (command.HasProperty("_value"))
{
var value = command["_value"] as BSonDoc;
var collection = (command["_collection"] ?? string.Empty).ToString();
method(value, collection, store);
}
}
