// Resolve the members (fields & methods)
public override void ResolveMemberDecls(
ISemanticResolver s,
ICLRtypeProvider provider
)
{
// If we've already been resolved, then skip
if (this.Symbol.MemberScope.IsLocked)
return;
// We need our base types to have resolved members so that we can
// do inheritence checks.
FixBaseMemberDecls(s, provider);
// Setup our context to do evaluation
Scope prev = s.SetCurrentContext(m_symbol.MemberScope);
s.SetCurrentClass(m_symbol);
// Add our members to our scope
{
// Do events first because they generate methods & fields
FixEvents(s, provider);
if (!IsInterface)
this.FixFields(s, provider);
// Resolve properties before methods, since properties create methods
foreach(PropertyDecl p in m_alProperties)
{
p.ResolveMember(m_symbol, s, provider);
}
// This can change both the normal methods as well as accessor methods on properties.
FixMethods(s, provider);
// Set property symbols after we've touched up the methods.
foreach(PropertyDecl p in m_alProperties)
{
p.Symbol.SetInfo(provider);
}
PostFixEvents(s, provider);
// Nested types
foreach(TypeDeclBase t in this.m_alNestedTypes)
{
t.ResolveMemberDecls(s, provider);
}
// If we have no ctor at all, then add a default one.
// (default ctor - takes no parameters, chains to base's default ctor)
if (!IsInterface)
FixCtors(s, provider);
// We're done adding to the scope, so lock it.
m_symbol.MemberScope.LockScope();
}
s.SetCurrentClass(null);
s.RestoreContext(prev);
}
// Resolve the bodies of methods
public override void ResolveBodies(ISemanticResolver s)
{
Scope scope = m_symbol.MemberScope;
//s.PushScope(scope);
Scope prev = s.SetCurrentContext(scope);
s.SetCurrentClass(m_symbol);
foreach(MethodDecl m in m_alMethods)
{
m.ResolveBodies(s);
}
foreach(PropertyDecl p in m_alProperties)
{
p.ResolveBodies(s);
}
// Nested
foreach(TypeDeclBase t in this.m_alNestedTypes)
{
t.ResolveBodies(s);
}
s.SetCurrentClass(null);
//s.PopScope(scope);
s.RestoreContext(prev);
}
// Semantic checking
// Stubs can be resolved in any order.
public override void ResolveTypesAsBlueStub(
ISemanticResolver s,
string stNamespace,
Scope scopeParent
)
{
// Get our name. Nested classes are separated with a '+'
// Namespaces are separated with a '.'
string stFullName = (stNamespace == "") ?
(m_strName) :
(stNamespace + "." + m_strName);
// Are we a nested class?
if (scopeParent.Node is ClassDecl)
{
Debug.Assert(stNamespace != "");
stFullName = stNamespace + "+" + m_strName;
}
// Create a stub sym entry to add to current scope
m_symbol = new TypeEntry(stFullName, this, m_genre, scopeParent);
scopeParent.AddSymbol(m_symbol);
// Stub on nested types
//s.PushScope(m_symbol.MemberScope);
// Our context is the same as the scope on our symbol
Scope context = m_symbol.MemberScope;
Debug.Assert(context != null);
s.SetCurrentClass(m_symbol);
foreach(TypeDeclBase t in this.m_alNestedTypes)
{
t.ResolveTypesAsBlueStub(s, stFullName, context);
}
s.SetCurrentClass(null);
//s.PopScope(m_symbol.MemberScope);
}
