public void SetInfo(ICLRtypeProvider provider)
{
//Debug.Assert(m_info == null);
//m_info =
provider.CreateCLREvent(this);
}
public void SetInfo(ICLRtypeProvider provider)
{
Debug.Assert(m_info == null);
// This will create a clr info for this property
// as well as the accessors
m_info = provider.CreateCLRProperty(this);
}
//-----------------------------------------------------------------------------
// Primary Worker. This drives the different stages.
// Returns the error code for all expected end-user errors.
// Unexpected errors (bugs / holes in the compiler) will throw an exception.
//-----------------------------------------------------------------------------
static int MainWorker(string[] arstSourceFiles)
{
if (arstSourceFiles == null)
{
PrintError_NoSourceFiles();
return(1);
}
// Check if debugging the lexer. Just do first file
// @todo - should we do all files?
if (ShouldDebugQuit(EStage.cLexer))
{
string stDefault = arstSourceFiles[0];
System.IO.StreamReader reader = new System.IO.StreamReader(stDefault);
ILexer lex = new ManualParser.Lexer(stDefault, reader);
return(TestLexer(lex));
}
//
// Lex & Parse all source files.
// It doesn't matter which order files are parsed in
//
AST.ProgramDecl root = ParseAllFiles(arstSourceFiles);
if (root == null)
{
return(1);
}
if (ShouldDebugQuit(EStage.cParser))
{
return(0);
}
//
// Symantic checks:
//
// Must startup codegen so that it can assign clr types
m_codegen.BeginOutput(arstSourceFiles);
System.Reflection.Assembly [] refs = LoadImportedAssemblies();
if (StdErrorLog.HasErrors())
{
return(19);
}
ICLRtypeProvider provider = m_codegen.GetProvider(refs);
ISemanticChecker check = new SymbolEngine.SemanticChecker();
bool fCheckOk = check.DoCheck(root, provider, refs);
if (!fCheckOk)
{
return(2);
}
// Dump parse tree after resolution
if (s_fGenerateXML)
{
string stOutput = IO.Path.GetFileNameWithoutExtension(arstSourceFiles[0]);
System.Xml.XmlWriter oSym = new System.Xml.XmlTextWriter(stOutput + "_sym.xml", null);
check.DumpSymbolTable(oSym);
System.Xml.XmlWriter oPost = new System.Xml.XmlTextWriter(stOutput + "_post.xml", null);
AST.Node.DumpTree(root, oPost);
}
if (ShouldDebugQuit(EStage.cSymbolResolution))
{
return(0);
}
//
// Codegen
//
m_codegen.DoCodeGen(root);
m_codegen.EndOutput();
// If we make it this far, we have no errors.
return(0);
}
public abstract void ResolveTypesAsCLR(
ISemanticResolver s,
ICLRtypeProvider provider
);
public void ResolveTypesAsCLR(
ISemanticResolver s,
ICLRtypeProvider provider
)
{
// We shouldn't have to update the scope stack since
// we should only be looking at resolved symbols
Scope prev = s.SetCurrentContext(m_context);
// add all classes in this namespace
{
foreach(TypeDeclBase e in m_arTypes)
e.ResolveTypesAsCLR(s, provider);
}
s.RestoreContext(prev);
// Recursively add all classes from nested namespaces
foreach(NamespaceDecl n in NestedNamespaces)
n.ResolveTypesAsCLR(s, provider);
}
// Semantic checking
public override void ResolveMember(
TypeEntry symDefiningClass,
ISemanticResolver s,
ICLRtypeProvider provider
)
{
//TypeEntry tRetType = null;
if (!IsCtor)
{
m_tRetType.ResolveType(s);
//tRetType = m_tRetType.TypeRec;
}
else
{
ClassDecl nodeClass = symDefiningClass.Node;
if (Mods.IsStatic)
{
// Checks on static ctors
if (this.Params.Length != 0)
{
//s.ThrowError_NoParamsOnStaticCtor(this);
ThrowError(SymbolError.NoParamsOnStaticCtor(this));
}
// Rename to avoid a naming collision w/ a default ctor.
// Since no one will call a static ctor (and codegen ignores ctor names),
// we can pick anything here.
//this.m_strName = "$static_ctor";
this.m_idName = new Identifier("$static_ctor", m_idName.Location);
// Is there a static field initializer to chain to?
if (nodeClass.StaticInitMethod != null)
{
/*
Statement stmt = new ExpStatement(
new MethodCallExp(
null,
new Identifier(nodeClass.StaticInitMethod.Name, nodeClass.StaticInitMethod.Location),
new ArgExp[0]
));
*/
// If there are Static, ReadOnly fields, then they must be assigned directly
// in a constructor, not in a function called by the constructor.
Statement stmt = nodeClass.StaticInitMethod.Body;
Body.InjectStatementAtHead(stmt);
}
} // static ctor
else
{
if (nodeClass.InstanceInitMethod != null)
{
// Chain to an instance-field initializer if we don't chain to
// a this() ctor.
CtorChainStatement chain = (this.Body.Statements[0]) as CtorChainStatement;
Debug.Assert(chain != null);
if (chain.TargetType == CtorChainStatement.ETarget.cBase)
{
/*
Statement stmt = new MethodCallStatement(
new MethodCallExp(
null,
new Identifier(nodeClass.InstanceInitMethod.Name, nodeClass.InstanceInitMethod.Location),
new ArgExp[0]
));
*/
// PEVerify barfs if we try to do an instance method call in the ctor,
// so just inject the raw method body. It's just a bunch of assigns anyway,
// so we're ok.
Statement stmt = nodeClass.InstanceInitMethod.Body;
Body.InjectStatementAtHead(stmt);
}
}
} // instance ctor
}
// Add new sym entry to our parent class's scope
MethodExpEntry m = new MethodExpEntry(
Name,
this,
symDefiningClass,
IsCtor ? null : m_tRetType.BlueType
);
m.m_scope = new Scope(
"method: " + symDefiningClass.m_strName + "." + Name,
this,
symDefiningClass.MemberScope);
m_symbol = m;
//s.PushScope(m.m_scope);
Scope prev = s.SetCurrentContext(m.m_scope);
// resolve params (because we'll need them for overloading)
// Add param 0 for 'this' (if not static)
// For structs, "this" is a reference, for classes, it's a value.
if (!Mods.IsStatic)
{
ParamVarExpEntry e = new ParamVarExpEntry();
e.m_strName = "this";
TypeEntry t = m_symbol.SymbolClass;
if (t.IsStruct)
{
t = new RefTypeEntry(t, s);
}
e.m_type = t; // 'this' is the type of the containg class
e.CodeGenSlot = 0;
s.GetCurrentContext().AddSymbol(e);
}
// do rest of the params
foreach(ParamVarDecl param in m_arParams)
{
param.ResolveVarDecl(s);
}
//s.PopScope(m.m_scope);
s.RestoreContext(prev);
symDefiningClass.AddMethodToScope(m);
}
// Resolve this
public override void ResolveMember(
TypeEntry symDefiningClass,
ISemanticResolver s,
ICLRtypeProvider provider
)
{
m_tType.ResolveType(s);
// Spoof bodies
if (HasGet)
{
m_declGet.ResolveMember(symDefiningClass, s, null);
m_declGet.Symbol.IsSpecialName = true;
}
if (HasSet)
{
m_declSet.ResolveMember(symDefiningClass, s, null);
m_declSet.Symbol.IsSpecialName = true;
}
// Create a symbol for the property
m_symbol = new SymbolEngine.PropertyExpEntry(symDefiningClass, this, m_declGet, m_declSet);
s.GetCurrentContext().AddSymbol(m_symbol);
}
// Resolve the events
public override void ResolveMember(
TypeEntry symDefiningClass,
ISemanticResolver s,
ICLRtypeProvider provider
)
{
m_tType.ResolveType(s);
m_symbol = new EventExpEntry(symDefiningClass, this);
s.GetCurrentContext().AddSymbol(m_symbol);
// If an event has no handlers
if (m_addMethod == null && m_addMethod == null)
{
FixDefaultHandlers(symDefiningClass, s, provider);
}
Debug.Assert(m_addMethod != null && m_removeMethod != null);
Debug.Assert(m_addMethod.Symbol == null); // shouldn't have resolved handlers yet
Debug.Assert(m_removeMethod.Symbol == null);
// The handlers should be treated just like normal methods..
ClassDecl c = symDefiningClass.Node;
c.AddMethodToList(m_addMethod);
c.AddMethodToList(m_removeMethod);
}
public void SetInfo(ICLRtypeProvider provider)
{
Debug.Assert(m_info == null);
// This will create a clr info for this property
// as well as the accessors
m_info = provider.CreateCLRProperty(this);
}
public override void ResolveMemberDecls(
ISemanticResolver s,
ICLRtypeProvider provider
)
{
Scope scope = m_symbol.MemberScope;
int iLastValue = -1;
Scope prev = s.SetCurrentContext(scope);
for(int i = 0; i < this.Fields.Length; i++)
{
FieldDecl f = this.Fields[i];
Exp e = f.InitialExp;
//Debug.Assert(e != null);
// Evaluate e to a literal...
//Exp.TrySimplify(ref e);
int iValue;
if (e != null)
{
IntExp e2 = e as IntExp;
Debug.Assert(e2 != null, "Can only assign to an integer literal"); //@todo - legit error
iValue = e2.Value;
}
else
{
if (i == 0)
iValue = 0;
else
iValue = iLastValue + 1;
}
// Need to create an object of type 'ThisEnum' with integer value iValue;
//Type tEnum = this.Symbol.CLRType;
// errors
//System.ComponentModel.TypeConverter c = new System.ComponentModel.TypeConverter();
//object o2 = c.ConvertTo(iValue, tEnum);
// errors
// object oValue = System.Enum.ToObject(tEnum, iValue);
iLastValue = iValue;
f.ResolveMemberAsLiteral(this.m_symbol, s, iValue);
LiteralFieldExpEntry l = (LiteralFieldExpEntry) f.Symbol;
l.SetInfo(provider);
}
//s.PopScope(scope);
s.RestoreContext(prev);
}
public override void ResolveTypesAsCLR(
ISemanticResolver s,
ICLRtypeProvider provider
)
{
if (m_symbol.CLRType != null)
return;
m_symbol.SetCLRType(provider); // enum
s.AddClrResolvedType(this.Symbol);
}
public override void ResolveMemberDecls(
ISemanticResolver s,
ICLRtypeProvider provider
)
{
this.m_nodeProxy.ResolveMemberDecls(s, provider);
}
public override void ResolveTypesAsCLR(
ISemanticResolver s,
ICLRtypeProvider provider
)
{
this.m_nodeProxy.ResolveTypesAsCLR(s, provider);
}
//-----------------------------------------------------------------------------
// Main checking routine
// Return true if successful, else false
//-----------------------------------------------------------------------------
public bool DoCheck(
AST.ProgramDecl p,
ICLRtypeProvider provider,
Assembly [] refs
)
{
Debug.Assert(provider != null);
Debug.Assert(p != null);
m_provider = provider;
string stSubPhase = "";
try
{
m_scopeGlobal = new Scope("Global", null, null);
// Import symbols
stSubPhase = "importing assemblies";
ImportAssembly(GetMscorlib());
AddDefaultTypes(m_scopeGlobal);
foreach(Assembly a in refs)
{
ImportAssembly(a);
}
// Pass 1 - Resolve the namespaces and stub the types.
// This will stub all scopes and create a lexical-scope tree.
stSubPhase = "resolving namespaces";
p.ResolveNamespace(this, m_scopeGlobal);
// Pass 2 - Resolve Types (to both CLR & Blue)
stSubPhase = "resolving to clr types";
p.ResolveTypes(this, provider);
// Pass 3 - resolve class member declarations (Methods & fields)
stSubPhase = "resolving member declarations";
p.ResolveMemberDecls(this, provider);
// Pass 4 - resolve method bodies
stSubPhase = "resolving member bodies";
p.ResolveBodies(this);
// Final Debug verify before codegen
stSubPhase = "final debug check";
p.DebugCheck(this);
m_scopeGlobal.DebugCheck(this);
p.NotifyResolutionDone();
return true;
}
// Strip away SymbolErrors; we've already reported them when we first threw them.
catch (SymbolError.SymbolErrorException)
{
return false;
}
catch(System.Exception e)
{
Blue.Driver.PrintError_InternalError(e, "Symbol Resolution(" + stSubPhase + ")");
return false;
}
}
public virtual void SetInfo(ICLRtypeProvider provider)
{
Debug.Assert(m_info == null);
m_info = provider.CreateCLRField(this);
}
public override void SetInfo(ICLRtypeProvider provider)
{
Debug.Assert(m_info == null);
m_info = provider.CreateCLRLiteralField(this);
}
public override void SetInfo(ICLRtypeProvider provider)
{
Debug.Assert(m_info == null);
m_info = provider.CreateCLRLiteralField(this);
}
// Called after we've resolved as a blue type
// Pair this type with a CLR type obtained via the Provider
// Recursively call on all inherited types (base class & interfaces)
public override void ResolveTypesAsCLR(
ISemanticResolver s,
ICLRtypeProvider provider
)
{
// Since this can be called recursively, bail if we're already resolved.
if (this.Symbol.IsInit)
return;
// S is already set to the context that we're evaluating in.
Scope prev = s.SetCurrentContext(this.Symbol.MemberScope.LexicalParent);
FixBaseTypes(s, provider); // this is recursive
CreateCLRType(s, provider);
s.RestoreContext(prev);
}
// Resolve the member given a symbol for the class we're defined in, a resolver,
// and a provider
public abstract void ResolveMember(
TypeEntry symDefiningClass,
ISemanticResolver s,
ICLRtypeProvider provider
);
// Now that all the types have been stubbed and established their context,
// we can recursively run through and resolve all of our base types.
void FixBaseTypes(
ISemanticResolver s,
ICLRtypeProvider provider
)
{
TypeEntry tSuper = null;
BeginCheckCycle(s);
ArrayList alInterfaces = new ArrayList();
// Decide who our super class is and which interfaces we're inheriting
foreach(TypeSig sig in this.m_arSuper)
{
sig.ResolveType(s);
TypeEntry t = sig.BlueType;
// Make sure this base type is resolved. Do this recursively
ClassDecl c = t.Node;
if (c != null)
{
c.ResolveTypesAsCLR(s, provider);
}
if (t.IsClass)
{
Debug.Assert(this.IsClass, "Only a class can have a super-class");
if (tSuper != null)
{
ThrowError(SymbolError.OnlySingleInheritence(this));
}
tSuper = t;
} else {
// Both structs & interfaces can only derive from interfaces (not classes)
if (!t.IsInterface)
ThrowError(SymbolError.MustDeriveFromInterface(this, t));
alInterfaces.Add(t);
}
}
TypeEntry [] tInterfaces = new TypeEntry[alInterfaces.Count];
for(int i = 0; i < alInterfaces.Count; i++)
tInterfaces[i] = (TypeEntry) alInterfaces[i];
// If no super class is specified, then we use as follows:
// 'Interface' has no super class,
// 'Class' has 'System.Object'
// 'Struct' has 'System.ValueType'
if (!IsInterface && (tSuper == null))
{
if (IsClass)
tSuper = s.ResolveCLRTypeToBlueType(typeof(object));
if (IsStruct)
tSuper = s.ResolveCLRTypeToBlueType(typeof(System.ValueType));
}
Debug.Assert(IsInterface ^ (tSuper != null));
// Just to sanity check, make sure the symbol stub is still there
#if DEBUG
TypeEntry sym = (TypeEntry) s.GetCurrentContext().LookupSymbolInThisScopeOnly(m_strName);
Debug.Assert(sym == m_symbol);
#endif
m_symbol.InitLinks(tSuper, tInterfaces);
// Make sure all of our base types are resolved
foreach(TypeEntry t in this.Symbol.BaseInterfaces)
{
t.EnsureResolved(s);
}
if (Symbol.Super != null)
Symbol.Super.EnsureResolved(s);
// Final call. Set super scope
m_symbol.FinishInit();
EndCheckCycle();
}
// Resolve member
public override void ResolveMember(
TypeEntry symDefiningClass,
ISemanticResolver s,
ICLRtypeProvider provider
)
{
m_tType.ResolveType(s);
TypeEntry t = m_tType.BlueType;
m_symbol = new FieldExpEntry(m_stName, t, symDefiningClass, this);
s.GetCurrentContext().AddSymbol(m_symbol);
m_symbol.SetInfo(provider);
}
// Requires that all of our base types have been resolved.
void CreateCLRType(
ISemanticResolver s,
ICLRtypeProvider provider)
{
// Should have already resolved as a blue type
Debug.Assert(this.Symbol != null);
BeginCheckCycle(s);
// Now that all of our dependent classes have their clr type set,
// we can go ahead and set ours.
// Note that a derived class may have already set ours, so we have
// to check
if (Symbol.CLRType == null)
{
// Get the clr type and then update the symbol engine
this.Symbol.SetCLRType(provider);
s.AddClrResolvedType(this.Symbol);
}
Debug.Assert(this.Symbol.CLRType != null);
// Nested classes
foreach(TypeDeclBase t in this.m_alNestedTypes)
{
t.ResolveTypesAsCLR(s, provider);
}
EndCheckCycle();
}
// Resolve the types
public void ResolveTypes(
ISemanticResolver s,
ICLRtypeProvider provider)
{
// Then go through and resolve them to CLR types.
foreach(NamespaceDecl n in m_nGlobal)
n.ResolveTypesAsCLR(s, provider);
}
// Make sure that all of our base types are resolved.
void FixBaseMemberDecls(ISemanticResolver s, ICLRtypeProvider provider)
{
if (this.IsClass)
{
if (this.Symbol.Super.Node != null)
this.Symbol.Super.Node.ResolveMemberDecls(s, provider);
}
foreach(TypeEntry t in this.Symbol.BaseInterfaces)
{
if (t.Node != null)
t.Node.ResolveMemberDecls(s, provider);
}
}
// Resolve the member declarations within a class.
// Since these can refer to other classes, we must have
// resolved all types before resolving any members
public void ResolveMemberDecls(
ISemanticResolver s,
ICLRtypeProvider provider
)
{
foreach(NamespaceDecl n in m_nGlobal)
n.ResolveMemberDecls(s, provider);
}
// Resolve all the fields in this type. Only class/struct should call
// this.
void FixFields(ISemanticResolver s, ICLRtypeProvider provider)
{
Debug.Assert(!IsInterface);
int cInstance = 0;
int cStatic = 0;
foreach(FieldDecl f in m_alFields)
{
f.ResolveMember(m_symbol, s, provider);
//f.Symbol.SetInfo(provider);
if (f.InitialExp != null)
if (f.Mods.IsStatic)
cStatic++;
else
cInstance++;
}
Statement [] stmtStatic = new Statement[cStatic];
Statement [] stmtInstance = new Statement[cInstance];
cStatic = 0;
cInstance = 0;
// Fields can have assignments. Make 2 helper functions to do
// assignment for static & instance fields
foreach(FieldDecl f in m_alFields)
{
if (f.InitialExp != null)
{
Statement stmt = new ExpStatement(new AssignStmtExp(
new SimpleObjExp(new Identifier(f.Name, f.Location)), f.InitialExp));
if (f.Mods.IsStatic)
{
stmtStatic[cStatic] = stmt;
cStatic++;
}
else
{
if (IsStruct)
{
//ThrowError_NoFieldInitForStructs(s, f);
ThrowError(SymbolError.NoFieldInitForStructs(f));
}
stmtInstance[cInstance] = stmt;
cInstance ++;
}
} // end has initializer expression
}
Debug.Assert(cStatic == stmtStatic.Length);
Debug.Assert(cInstance == stmtInstance.Length);
// Create methods to initialize the static & instance fields.
// Then the ctors can call these methods
if (cStatic != 0)
{
Modifiers mods = new Modifiers();
mods.SetStatic();
mods.SetPrivate();
m_nodeStaticInit = new MethodDecl(
new Identifier(".StaticInit", this.Location),
new ResolvedTypeSig(typeof(void), s),
new ParamVarDecl[0],
new BlockStatement(null, stmtStatic),
mods
);
//AddMethodToList(m_nodeStaticInit);
}
if (cInstance != 0)
{
Modifiers mods = new Modifiers();
mods.SetPrivate();
m_nodeInstanceInit = new MethodDecl(
new Identifier(".InstanceInit", this.Location),
new ResolvedTypeSig(typeof(void), s),
new ParamVarDecl[0],
new BlockStatement(null, stmtInstance),
mods
);
AddMethodToList(m_nodeInstanceInit);
}
} // end fields
public void ResolveMemberDecls(
ISemanticResolver s,
ICLRtypeProvider provider
)
{
// Do for all types in this namespace
foreach(TypeDeclBase e in m_arTypes)
e.ResolveMemberDecls(s, provider);
// Recursively do all classes from nested namespaces
foreach(NamespaceDecl n in NestedNamespaces)
n.ResolveMemberDecls(s, provider);
}
void FixMethods(
ISemanticResolver s,
ICLRtypeProvider provider
)
{
#if DEBUG
Debug.Assert(!m_fLockMethodList);
m_fLockMethodList = true;
#endif
// Resolve all methods, do some inheritence checks too:
// - if a class has any abstract members, it must be abstract
bool fHasAbstractMember = false;
foreach(MethodDecl m in m_alMethods)
{
// set provider=null since we have to tweak members based off inheritence checks
m.ResolveMember(m_symbol, s, null);
if (m.Mods.IsAbstract)
fHasAbstractMember = true;
}
Debug.Assert(!fHasAbstractMember || !this.IsStruct, "Only classes / interfaces can have abstract members");
// If we have any abstract members, then the class must be abstract
if (fHasAbstractMember && !this.Mods.IsAbstract)
PrintError(SymbolError.ClassMustBeAbstract(this));
// Do some checks that will modify how we create the CLR type.
if (!IsInterface)
{
// Make sure that we implement all methods from all the interfaces
// that we inherit from
foreach(TypeEntry t in this.Symbol.BaseInterfaces)
EnsureMethodsImplemented(s, t);
}
foreach(MethodDecl m in m_alMethods)
{
m.Symbol.SetInfo(provider);
// If a method is 'override', an exact match must exist in a super clas that:
// a) is marked 'override' also
// b) is marked 'virtual'
if (m.Mods.IsOverride)
{
TypeEntry t = this.Symbol.Super;
MethodExpEntry mSuper = t.LookupExactMethod(m.Symbol); // search super classes
if (mSuper == null)
{
PrintError(SymbolError.NoMethodToOverride(m.Symbol));
}
// Further checks if we found an method that matched sigs
else
{
// Get the CLR representaitons for this & the super
System.Reflection.MethodBase i1 = m.Symbol.Info;
System.Reflection.MethodBase i2 = mSuper.Info;
// if final, error
if (i2.IsFinal)
{
PrintError(SymbolError.CantOverrideFinal(m.Symbol, mSuper));
}
// If !virtual, error
if (!i2.IsVirtual)
{
PrintError(SymbolError.CantOverrideNonVirtual(m.Symbol, mSuper));
}
// Check same visibility access
bool fMatch =
(i1.IsPublic == i2.IsPublic) &&
(i1.IsPrivate == i2.IsPrivate) &&
(i1.IsFamily == i2.IsFamily) &&
(i1.IsAssembly == i2.IsAssembly);
if (!fMatch)
{
PrintError(SymbolError.VisibilityMismatch(m.Symbol));
}
}
} // IsOverride
} // foreach Method
}
public abstract void ResolveMemberDecls(
ISemanticResolver s,
ICLRtypeProvider provider
);
void FixCtors(
ISemanticResolver s,
ICLRtypeProvider provider
)
{
// Add default ctor
bool fFoundCtor = m_symbol.HasMethodHeader(Name);
// Note that structs don't have a default ctor, but can have other ctors
// But add a default ctor for classes if we don't have one.
if (!fFoundCtor && IsClass)
{
CtorChainStatement stmtChain = new CtorChainStatement();
Modifiers mods = new Modifiers();
mods.SetPublic();
MethodDecl mdecl = new MethodDecl(
new Identifier(Name, this.Location),
null,
null,
new BlockStatement(new LocalVarDecl[0], new Statement[] { stmtChain }),
//new AST.Modifiers(AST.Modifiers.EFlags.Public)
mods
);
stmtChain.FinishInit(mdecl);
mdecl.ResolveMember(m_symbol,s, null);
mdecl.Symbol.SetInfo(provider);
// Add to the end of the m_alMethods array so that we get codegen'ed!
AddMethodToList(mdecl);
Debug.Assert(m_symbol.HasMethodHeader(Name));
}
// @todo - perhaps we could just make the static initializer a static-ctor..
// If we don't have a static ctor, but we do have static data, then add
// a static ctor
if (m_nodeStaticInit != null)
{
bool fFoundStaticCtor = false;
foreach(MethodDecl m in m_alMethods)
{
if (m.Mods.IsStatic && m.IsCtor)
{
fFoundStaticCtor = true;
break;
}
}
if (!fFoundStaticCtor)
{
Modifiers mods = new Modifiers();
mods.SetStatic();
mods.SetPublic();
MethodDecl mdecl2 = new MethodDecl(
new Identifier(Name, this.Location),
null,
null,
new BlockStatement(null, new Statement[]{}),
//new Modifiers(AST.Modifiers.EFlags.Static | Modifiers.EFlags.Public)
mods
);
mdecl2.ResolveMember(m_symbol, s, null);
mdecl2.Symbol.SetInfo(provider);
AddMethodToList(mdecl2);
}
} // end check static ctor
} // fix ctors
public void SetInfo(ICLRtypeProvider provider)
{
Debug.Assert(m_infoMethod == null);
m_infoMethod = provider.CreateCLRMethod(this);
}
} // fix ctors
// Resolve all events in the class
void FixEvents(
ISemanticResolver s,
ICLRtypeProvider provider
)
{
if (this.IsStruct)
return;
if (Events == null)
return;
foreach(EventDecl e in this.Events)
{
e.ResolveMember(m_symbol, s, provider);
}
}
// Called after all the methods are decled.
void PostFixEvents(
ISemanticResolver s,
ICLRtypeProvider provider
)
{
#if DEBUG
Debug.Assert(m_fLockMethodList, "Don't PostResolve Events until after methods");
#endif
if (Events == null)
return;
foreach(EventDecl e in this.Events)
{
e.PostResolveMember(s);
// e.FieldSymbol.SetInfo(provider);
}
}
// 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);
}
public virtual void SetInfo(ICLRtypeProvider provider)
{
Debug.Assert(m_info == null);
m_info = provider.CreateCLRField(this);
}
public void SetInfo(ICLRtypeProvider provider)
{
//Debug.Assert(m_info == null);
//m_info =
provider.CreateCLREvent(this);
}
