public Scope CreateScope(Scope parent)
{
Scope sym = newBasicSym(SYMKIND.SK_Scope, null, parent).AsScope();
if (parent != null)
{
sym.nestingOrder = parent.nestingOrder + 1;
}
return sym;
}
/////////////////////////////////////////////////////////////////////////////////
private EXPRBOUNDLAMBDA GenerateBoundLambda(
ArgumentObject[] arguments,
Scope pScope,
EXPR call)
{
// We don't actually need the real delegate type here - we just need SOME delegate type.
// This is because we never attempt any conversions on the lambda itself.
AggregateType delegateType = _symbolTable.GetCTypeFromType(typeof(Func<>)).AsAggregateType();
LocalVariableSymbol thisLocal = _semanticChecker.GetGlobalSymbolFactory().CreateLocalVar(_semanticChecker.GetNameManager().Add("this"), pScope, _symbolTable.GetCTypeFromType(typeof(object)));
thisLocal.isThis = true;
EXPRBOUNDLAMBDA boundLambda = _exprFactory.CreateAnonymousMethod(delegateType);
EXPRUNBOUNDLAMBDA unboundLambda = _exprFactory.CreateLambda();
List<Type> paramTypes = new List<Type>();
foreach (ArgumentObject o in arguments)
{
paramTypes.Add(o.Type);
}
boundLambda.Initialize(pScope);
EXPRRETURN returnStatement = _exprFactory.CreateReturn(0, pScope, call);
EXPRBLOCK block = _exprFactory.CreateBlock(null, returnStatement, pScope);
boundLambda.OptionalBody = block;
return boundLambda;
}
/////////////////////////////////////////////////////////////////////////////////
// We take the ArgumentObjects to verify - if the parameter expression tells us
// we have a ref parameter, but the argument object tells us we're not passed by ref,
// then it means it was a ref that the compiler had to insert. This is used when
// we have a call off of a struct for example. If thats the case, don't treat the
// local as a ref type.
private void PopulateLocalScope(
DynamicMetaObjectBinder payload,
Scope pScope,
ArgumentObject[] arguments,
IEnumerable<Expression> parameterExpressions,
Dictionary<int, LocalVariableSymbol> dictionary)
{
// We use the compile time types for the local variables, and then
// cast them to the runtime types for the expression tree.
int i = 0;
foreach (Expression parameter in parameterExpressions)
{
CType type = _symbolTable.GetCTypeFromType(parameter.Type);
// Make sure we're not setting ref for the receiver of a call - the argument
// will be marked as ref if we're calling off a struct, but we don't want
// to persist that in our system.
bool isFirstParamOfCallOrInvoke = false;
if (i == 0 && IsBinderThatCanHaveRefReceiver(payload))
{
isFirstParamOfCallOrInvoke = true;
}
// If we have a ref or out, get the parameter modifier type.
if ((parameter is ParameterExpression && (parameter as ParameterExpression).IsByRef) &&
(arguments[i].Info.IsByRef || arguments[i].Info.IsOut))
{
// If we're the first param of a call or invoke, and we're ref, it must be
// because of structs. Don't persist the parameter modifier type.
if (!isFirstParamOfCallOrInvoke)
{
type = _semanticChecker.GetTypeManager().GetParameterModifier(type, arguments[i].Info.IsOut);
}
}
LocalVariableSymbol local = _semanticChecker.GetGlobalSymbolFactory().CreateLocalVar(_semanticChecker.GetNameManager().Add("p" + i), pScope, type);
local.fUsedInAnonMeth = true;
dictionary.Add(i++, local);
isFirstParamOfCallOrInvoke = false;
}
}
/////////////////////////////////////////////////////////////////////////////////
private Expression CreateExpressionTreeFromResult(
IEnumerable<Expression> parameters,
ArgumentObject[] arguments,
Scope pScope,
EXPR pResult)
{
// (3) - Place the result in a return statement and create the EXPRBOUNDLAMBDA.
EXPRBOUNDLAMBDA boundLambda = GenerateBoundLambda(arguments, pScope, pResult);
// (4) - Rewrite the EXPRBOUNDLAMBDA into an expression tree.
EXPR exprTree = ExpressionTreeRewriter.Rewrite(boundLambda, _exprFactory, SymbolLoader);
// (5) - Create the actual Expression Tree
Expression e = ExpressionTreeCallRewriter.Rewrite(SymbolLoader.GetTypeManager(), exprTree, parameters);
return e;
}
protected Symbol newBasicSym(
SYMKIND kind,
Name name,
ParentSymbol parent)
{
// The parser creates names with PN_MISSING when attempting to recover from errors
// To prevent spurious errors, we create SYMs with a different name (PN_MISSINGSYM)
// so that they are never found when doing lookup.
if (name == m_pMissingNameNode)
{
name = m_pMissingNameSym;
}
Symbol sym;
switch (kind)
{
case SYMKIND.SK_NamespaceSymbol:
sym = new NamespaceSymbol();
sym.name = name;
break;
case SYMKIND.SK_NamespaceDeclaration:
sym = new NamespaceDeclaration();
sym.name = name;
break;
case SYMKIND.SK_AssemblyQualifiedNamespaceSymbol:
sym = new AssemblyQualifiedNamespaceSymbol();
sym.name = name;
break;
case SYMKIND.SK_AggregateSymbol:
sym = new AggregateSymbol();
sym.name = name;
break;
case SYMKIND.SK_AggregateDeclaration:
sym = new AggregateDeclaration();
sym.name = name;
break;
case SYMKIND.SK_TypeParameterSymbol:
sym = new TypeParameterSymbol();
sym.name = name;
break;
case SYMKIND.SK_FieldSymbol:
sym = new FieldSymbol();
sym.name = name;
break;
case SYMKIND.SK_LocalVariableSymbol:
sym = new LocalVariableSymbol();
sym.name = name;
break;
case SYMKIND.SK_MethodSymbol:
sym = new MethodSymbol();
sym.name = name;
break;
case SYMKIND.SK_PropertySymbol:
sym = new PropertySymbol();
sym.name = name;
break;
case SYMKIND.SK_EventSymbol:
sym = new EventSymbol();
sym.name = name;
break;
case SYMKIND.SK_TransparentIdentifierMemberSymbol:
sym = new TransparentIdentifierMemberSymbol();
sym.name = name;
break;
case SYMKIND.SK_Scope:
sym = new Scope();
sym.name = name;
break;
case SYMKIND.SK_LabelSymbol:
sym = new LabelSymbol();
sym.name = name;
break;
case SYMKIND.SK_GlobalAttributeDeclaration:
sym = new GlobalAttributeDeclaration();
sym.name = name;
break;
case SYMKIND.SK_UnresolvedAggregateSymbol:
sym = new UnresolvedAggregateSymbol();
sym.name = name;
break;
case SYMKIND.SK_InterfaceImplementationMethodSymbol:
sym = new InterfaceImplementationMethodSymbol();
sym.name = name;
break;
case SYMKIND.SK_IndexerSymbol:
sym = new IndexerSymbol();
sym.name = name;
break;
case SYMKIND.SK_ParentSymbol:
sym = new ParentSymbol();
sym.name = name;
break;
case SYMKIND.SK_IteratorFinallyMethodSymbol:
sym = new IteratorFinallyMethodSymbol();
sym.name = name;
break;
default:
throw Error.InternalCompilerError();
}
sym.setKind(kind);
if (parent != null)
{
// Set the parent element of the child symbol.
parent.AddToChildList(sym);
m_pSymTable.InsertChild(parent, sym);
}
return (sym);
}
public EXPRWRAP CreateWrapNoAutoFree(Scope pCurrentScope, EXPR pOptionalWrap)
{
EXPRWRAP rval = CreateWrap(pCurrentScope, pOptionalWrap);
return rval;
}
public EXPRWRAP CreateWrap(
Scope pCurrentScope,
EXPR pOptionalExpression
)
{
EXPRWRAP rval = new EXPRWRAP();
rval.kind = ExpressionKind.EK_WRAP;
rval.type = null;
rval.flags = 0;
rval.SetOptionalExpression(pOptionalExpression);
if (pOptionalExpression != null)
{
rval.setType(pOptionalExpression.type);
}
rval.flags |= EXPRFLAG.EXF_LVALUE;
Debug.Assert(rval != null);
return (rval);
}
public EXPRBLOCK CreateBlock(EXPRBLOCK pOptionalCurrentBlock, EXPRSTMT pOptionalStatements, Scope pOptionalScope)
{
EXPRBLOCK rval = new EXPRBLOCK();
rval.kind = ExpressionKind.EK_BLOCK;
rval.type = null;
rval.flags = 0;
rval.SetOptionalStatements(pOptionalStatements);
rval.OptionalScopeSymbol = pOptionalScope;
Debug.Assert(rval != null);
return (rval);
}
public EXPRRETURN CreateReturn(EXPRFLAG nFlags, Scope pCurrentScope, EXPR pOptionalObject, EXPR pOptionalOriginalObject)
{
Debug.Assert(0 == (nFlags &
~(EXPRFLAG.EXF_ASLEAVE | EXPRFLAG.EXF_FINALLYBLOCKED | EXPRFLAG.EXF_RETURNISYIELD |
EXPRFLAG.EXF_ASFINALLYLEAVE | EXPRFLAG.EXF_GENERATEDSTMT | EXPRFLAG.EXF_MARKING |
EXPRFLAG.EXF_MASK_ANY
)
));
EXPRRETURN rval = new EXPRRETURN();
rval.kind = ExpressionKind.EK_RETURN;
rval.type = null;
rval.flags = nFlags;
rval.SetOptionalObject(pOptionalObject);
Debug.Assert(rval != null);
return (rval);
}
public EXPRRETURN CreateReturn(EXPRFLAG nFlags, Scope pCurrentScope, EXPR pOptionalObject)
{
return CreateReturn(nFlags, pCurrentScope, pOptionalObject, pOptionalObject);
}
private Scope _argumentScope; // The scope containing the names of the parameters
// The scope that will hold this anonymous function. This starts off as the outer scope and is then
// ratcheted down to the correct scope after the containing method is fully bound.
public void Initialize(Scope argScope)
{
Debug.Assert(argScope != null);
_argumentScope = argScope;
}
protected Symbol newBasicSym(
SYMKIND kind,
Name name,
ParentSymbol parent)
{
// The parser creates names with PN_MISSING when attempting to recover from errors
// To prevent spurious errors, we create SYMs with a different name (PN_MISSINGSYM)
// so that they are never found when doing lookup.
if (name == m_pMissingNameNode)
{
name = m_pMissingNameSym;
}
Symbol sym;
switch (kind)
{
case SYMKIND.SK_NamespaceSymbol:
sym = new NamespaceSymbol();
sym.name = name;
break;
case SYMKIND.SK_NamespaceDeclaration:
sym = new NamespaceDeclaration();
sym.name = name;
break;
case SYMKIND.SK_AssemblyQualifiedNamespaceSymbol:
sym = new AssemblyQualifiedNamespaceSymbol();
sym.name = name;
break;
case SYMKIND.SK_AggregateSymbol:
sym = new AggregateSymbol();
sym.name = name;
break;
case SYMKIND.SK_AggregateDeclaration:
sym = new AggregateDeclaration();
sym.name = name;
break;
case SYMKIND.SK_TypeParameterSymbol:
sym = new TypeParameterSymbol();
sym.name = name;
break;
case SYMKIND.SK_FieldSymbol:
sym = new FieldSymbol();
sym.name = name;
break;
case SYMKIND.SK_LocalVariableSymbol:
sym = new LocalVariableSymbol();
sym.name = name;
break;
case SYMKIND.SK_MethodSymbol:
sym = new MethodSymbol();
sym.name = name;
break;
case SYMKIND.SK_PropertySymbol:
sym = new PropertySymbol();
sym.name = name;
break;
case SYMKIND.SK_EventSymbol:
sym = new EventSymbol();
sym.name = name;
break;
case SYMKIND.SK_TransparentIdentifierMemberSymbol:
sym = new TransparentIdentifierMemberSymbol();
sym.name = name;
break;
case SYMKIND.SK_Scope:
sym = new Scope();
sym.name = name;
break;
case SYMKIND.SK_LabelSymbol:
sym = new LabelSymbol();
sym.name = name;
break;
case SYMKIND.SK_GlobalAttributeDeclaration:
sym = new GlobalAttributeDeclaration();
sym.name = name;
break;
case SYMKIND.SK_UnresolvedAggregateSymbol:
sym = new UnresolvedAggregateSymbol();
sym.name = name;
break;
case SYMKIND.SK_InterfaceImplementationMethodSymbol:
sym = new InterfaceImplementationMethodSymbol();
sym.name = name;
break;
case SYMKIND.SK_IndexerSymbol:
sym = new IndexerSymbol();
sym.name = name;
break;
case SYMKIND.SK_ParentSymbol:
sym = new ParentSymbol();
sym.name = name;
break;
case SYMKIND.SK_IteratorFinallyMethodSymbol:
sym = new IteratorFinallyMethodSymbol();
sym.name = name;
break;
default:
throw Error.InternalCompilerError();
}
sym.setKind(kind);
if (parent != null)
{
// Set the parent element of the child symbol.
parent.AddToChildList(sym);
m_pSymTable.InsertChild(parent, sym);
}
return(sym);
}