public void VisitAliasedType(AliasedType at)
{
if (at.Base != null)
{
at.Base.Accept(this);
}
else
{
GenUfcsAndStaticProperties(at);
}
}
// Only import symbol aliases are allowed to search in the parse cache
public AbstractType Visit(ImportSymbolNode importSymbolNode)
{
AbstractType ret = null;
var modAlias = importSymbolNode is ModuleAliasNode;
if (modAlias ? importSymbolNode.Type != null : importSymbolNode.Type.InnerDeclaration != null)
{
var mods = new List <DModule>();
var td = modAlias ? importSymbolNode.Type : importSymbolNode.Type.InnerDeclaration;
foreach (var mod in ctxt.ParseCache.LookupModuleName(td.ToString()))
{
mods.Add(mod);
}
if (mods.Count == 0)
{
ctxt.LogError(new NothingFoundError(importSymbolNode.Type));
}
else
if (mods.Count > 1)
{
var m__ = new List <ISemantic>();
foreach (var mod in mods)
{
m__.Add(new ModuleSymbol(mod, importSymbolNode.Type));
}
ctxt.LogError(new AmbiguityError(importSymbolNode.Type, m__));
}
var bt = mods.Count != 0 ? (AbstractType) new ModuleSymbol(mods[0], td) : null;
//TODO: Is this correct behaviour?
if (!modAlias)
{
var furtherId = ResolveFurtherTypeIdentifier(importSymbolNode.Type.ToString(false), new[] {
bt
}, ctxt, importSymbolNode.Type);
ctxt.CheckForSingleResult(furtherId, importSymbolNode.Type);
if (furtherId != null && furtherId.Length != 0)
{
bt = furtherId[0];
}
else
{
bt = null;
}
}
ret = new AliasedType(importSymbolNode, bt, importSymbolNode.Type);
}
return(ret);
}
public void CreateNew()
{
// Create a new instance of AliasedType
var aliasedType = new AliasedType();
// Gets all the attributes of the type
var attributes = aliasedType.GetType().GetCustomAttributes(false);
Assert.IsNotNull(attributes);
Assert.AreEqual(1, attributes.Length);
Assert.IsNotNull(attributes[0]);
Assert.IsInstanceOfType(attributes[0], typeof(AliasAttribute));
Assert.AreEqual("AliasedTestType", ((AliasAttribute)attributes[0]).Value);
}
static AbstractType HandleImportSymbolMatch (ImportSymbolNode importSymbolNode,ResolutionContext ctxt)
{
AbstractType ret = null;
var modAlias = importSymbolNode is ModuleAliasNode;
if (modAlias ? importSymbolNode.Type != null : importSymbolNode.Type.InnerDeclaration != null) {
var mods = new List<DModule> ();
var td = modAlias ? importSymbolNode.Type : importSymbolNode.Type.InnerDeclaration;
foreach (var mod in ctxt.ParseCache.LookupModuleName (td.ToString ()))
mods.Add (mod);
if (mods.Count == 0)
ctxt.LogError (new NothingFoundError (importSymbolNode.Type));
else
if (mods.Count > 1) {
var m__ = new List<ISemantic> ();
foreach (var mod in mods)
m__.Add (new ModuleSymbol (mod, importSymbolNode.Type));
ctxt.LogError (new AmbiguityError (importSymbolNode.Type, m__));
}
var bt = mods.Count != 0 ? (AbstractType)new ModuleSymbol (mods [0], td) : null;
//TODO: Is this correct behaviour?
if (!modAlias) {
var furtherId = ResolveFurtherTypeIdentifier (importSymbolNode.Type.ToString (false), new[] {
bt
}, ctxt, importSymbolNode.Type);
ctxt.CheckForSingleResult (furtherId, importSymbolNode.Type);
if (furtherId != null && furtherId.Length != 0)
bt = furtherId [0];
else
bt = null;
}
ret = new AliasedType (importSymbolNode, bt, importSymbolNode.Type);
}
return ret;
}
/// <summary>
/// The variable's or method's base type will be resolved (if auto type, the intializer's type will be taken).
/// A class' base class will be searched.
/// etc..
/// </summary>
public static AbstractType HandleNodeMatch(
INode m,
ResolverContextStack ctxt,
AbstractType resultBase = null,
object typeBase = null)
{
stackNum_HandleNodeMatch++;
/*
* Pushing a new scope is only required if current scope cannot be found in the handled node's hierarchy.
*/
bool popAfterwards = !ctxt.NodeIsInCurrentScopeHierarchy(m);
if (popAfterwards)
{
ctxt.PushNewScope(m is IBlockNode ? (IBlockNode)m : m.Parent as IBlockNode);
}
//HACK: Really dirty stack overflow prevention via manually counting call depth
var canResolveBaseGenerally = stackNum_HandleNodeMatch < 6;
var DoResolveBaseType = canResolveBaseGenerally &&
!ctxt.Options.HasFlag(ResolutionOptions.DontResolveBaseClasses) &&
(m.Type == null || m.Type.ToString(false) != m.Name);
AbstractType ret = null;
// To support resolving type parameters to concrete types if the context allows this, introduce all deduced parameters to the current context
if (canResolveBaseGenerally && resultBase is DSymbol)
{
ctxt.CurrentContext.IntroduceTemplateParameterTypes((DSymbol)resultBase);
}
// Only import symbol aliases are allowed to search in the parse cache
if (m is ImportSymbolAlias)
{
var isa = (ImportSymbolAlias)m;
if (isa.IsModuleAlias ? isa.Type != null : isa.Type.InnerDeclaration != null)
{
var mods = new List <DModule>();
var td = isa.IsModuleAlias ? isa.Type : isa.Type.InnerDeclaration;
foreach (var mod in ctxt.ParseCache.LookupModuleName(td.ToString()))
{
mods.Add(mod as DModule);
}
if (mods.Count == 0)
{
ctxt.LogError(new NothingFoundError(isa.Type));
}
else if (mods.Count > 1)
{
var m__ = new List <ISemantic>();
foreach (var mod in mods)
{
m__.Add(new ModuleSymbol(mod, isa.Type));
}
ctxt.LogError(new AmbiguityError(isa.Type, m__));
}
var bt = mods.Count != 0 ? (AbstractType) new ModuleSymbol(mods[0], td) : null;
//TODO: Is this correct behaviour?
if (!isa.IsModuleAlias)
{
var furtherId = ResolveFurtherTypeIdentifier(isa.Type.ToString(false), new[] { bt }, ctxt, isa.Type);
ctxt.CheckForSingleResult(furtherId, isa.Type);
if (furtherId != null && furtherId.Length != 0)
{
bt = furtherId[0];
}
else
{
bt = null;
}
}
ret = new AliasedType(isa, bt, isa.Type);
}
}
else if (m is DVariable)
{
var v = (DVariable)m;
AbstractType bt = null;
if (DoResolveBaseType)
{
var bts = TypeDeclarationResolver.Resolve(v.Type, ctxt);
if (bts != null && bts.Length != 0 && ctxt.CheckForSingleResult(bts, v.Type))
{
bt = bts[0];
}
// For auto variables, use the initializer to get its type
else if (v.Initializer != null)
{
bt = ExpressionSemantics.Evaluation.EvaluateType(v.Initializer, ctxt);
}
// Check if inside an foreach statement header
if (bt == null && ctxt.ScopedStatement != null)
{
bt = GetForeachIteratorType(v, ctxt);
}
}
// Note: Also works for aliases! In this case, we simply try to resolve the aliased type, otherwise the variable's base type
ret = v.IsAlias ?
(DSymbol) new AliasedType(v, bt, typeBase as ISyntaxRegion) :
new MemberSymbol(v, bt, typeBase as ISyntaxRegion);
}
else if (m is DMethod)
{
ret = new MemberSymbol((DNode)m,
DoResolveBaseType ? GetMethodReturnType((DMethod)m, ctxt) : null
, typeBase as ISyntaxRegion);
}
else if (m is DClassLike)
{
UserDefinedType udt = null;
var dc = (DClassLike)m;
var invisibleTypeParams = new Dictionary <string, TemplateParameterSymbol>();
/*
* Add 'superior' template parameters to the current symbol because the parameters
* might be re-used in the nested class.
*/
var tStk = new Stack <ResolverContext>();
do
{
var curCtxt = ctxt.Pop();
tStk.Push(curCtxt);
foreach (var kv in curCtxt.DeducedTemplateParameters)
{
if (!dc.ContainsTemplateParameter(kv.Key) &&
!invisibleTypeParams.ContainsKey(kv.Key))
{
invisibleTypeParams.Add(kv.Key, kv.Value);
}
}
} while (ctxt.PrevContextIsInSameHierarchy);
while (tStk.Count != 0)
{
ctxt.Push(tStk.Pop());
}
switch (dc.ClassType)
{
case DTokens.Struct:
ret = new StructType(dc, typeBase as ISyntaxRegion, invisibleTypeParams);
break;
case DTokens.Union:
ret = new UnionType(dc, typeBase as ISyntaxRegion, invisibleTypeParams);
break;
case DTokens.Class:
udt = new ClassType(dc, typeBase as ISyntaxRegion, null, null, invisibleTypeParams);
break;
case DTokens.Interface:
udt = new InterfaceType(dc, typeBase as ISyntaxRegion, null, invisibleTypeParams);
break;
case DTokens.Template:
ret = new TemplateType(dc, typeBase as ISyntaxRegion, invisibleTypeParams);
break;
default:
ctxt.LogError(new ResolutionError(m, "Unknown type (" + DTokens.GetTokenString(dc.ClassType) + ")"));
break;
}
if (dc.ClassType == DTokens.Class || dc.ClassType == DTokens.Interface)
{
if (canResolveBaseGenerally &&
!ctxt.Options.HasFlag(ResolutionOptions.DontResolveBaseClasses))
{
ret = DResolver.ResolveBaseClasses(udt, ctxt);
}
else
{
ret = udt;
}
}
}
else if (m is IAbstractSyntaxTree)
{
var mod = (IAbstractSyntaxTree)m;
if (typeBase != null && typeBase.ToString() != mod.ModuleName)
{
var pack = ctxt.ParseCache.LookupPackage(typeBase.ToString()).First();
if (pack != null)
{
ret = new PackageSymbol(pack, typeBase as ISyntaxRegion);
}
}
else
{
ret = new ModuleSymbol(m as DModule, typeBase as ISyntaxRegion);
}
}
else if (m is DEnum)
{
ret = new EnumType((DEnum)m, typeBase as ISyntaxRegion);
}
else if (m is TemplateParameterNode)
{
//ResolveResult[] templateParameterType = null;
//TODO: Resolve the specialization type
//var templateParameterType = TemplateInstanceHandler.ResolveTypeSpecialization(tmp, ctxt);
ret = new TemplateParameterSymbol((TemplateParameterNode)m, null, typeBase as ISyntaxRegion);
}
if (canResolveBaseGenerally && resultBase is DSymbol)
{
ctxt.CurrentContext.RemoveParamTypesFromPreferredLocals((DSymbol)resultBase);
}
if (popAfterwards)
{
ctxt.Pop();
}
stackNum_HandleNodeMatch--;
return(ret);
}
public ulong VisitAliasedType(AliasedType t)
{
return(1001743);
}
/// <summary>
/// The variable's or method's base type will be resolved (if auto type, the intializer's type will be taken).
/// A class' base class will be searched.
/// etc..
/// </summary>
public static AbstractType HandleNodeMatch(
INode m,
ResolverContextStack ctxt,
AbstractType resultBase = null,
object typeBase = null)
{
stackNum_HandleNodeMatch++;
bool popAfterwards = m.Parent != ctxt.ScopedBlock && m.Parent is IBlockNode;
if (popAfterwards)
ctxt.PushNewScope((IBlockNode)m.Parent);
//HACK: Really dirty stack overflow prevention via manually counting call depth
var canResolveBaseGenerally = stackNum_HandleNodeMatch < 6;
var DoResolveBaseType = canResolveBaseGenerally &&
!ctxt.Options.HasFlag(ResolutionOptions.DontResolveBaseClasses) &&
(m.Type == null || m.Type.ToString(false) != m.Name);
AbstractType ret = null;
// To support resolving type parameters to concrete types if the context allows this, introduce all deduced parameters to the current context
if (canResolveBaseGenerally && resultBase is DSymbol)
ctxt.CurrentContext.IntroduceTemplateParameterTypes((DSymbol)resultBase);
// Only import symbol aliases are allowed to search in the parse cache
if (m is ImportSymbolAlias)
{
var isa = (ImportSymbolAlias)m;
if (isa.IsModuleAlias ? isa.Type != null : isa.Type.InnerDeclaration != null)
{
var mods = new List<DModule>();
var td=isa.IsModuleAlias ? isa.Type : isa.Type.InnerDeclaration;
foreach (var mod in ctxt.ParseCache.LookupModuleName(td.ToString()))
mods.Add(mod as DModule);
if(mods.Count == 0)
ctxt.LogError(new NothingFoundError(isa.Type));
else if(mods.Count > 1)
{
var m__=new List<ISemantic>();
foreach(var mod in mods)
m__.Add(new ModuleSymbol(mod, isa.Type));
ctxt.LogError(new AmbiguityError(isa.Type,m__));
}
var bt=mods.Count != 0 ? (AbstractType)new ModuleSymbol(mods[0], td) : null;
//TODO: Is this correct behaviour?
if (!isa.IsModuleAlias){
var furtherId = ResolveFurtherTypeIdentifier(isa.Type.ToString(false), new[]{ bt }, ctxt, isa.Type);
ctxt.CheckForSingleResult(furtherId, isa.Type);
if (furtherId != null && furtherId.Length != 0)
bt = furtherId[0];
else
bt = null;
}
ret = new AliasedType(isa, bt, isa.Type);
}
}
else if (m is DVariable)
{
var v = (DVariable)m;
AbstractType bt = null;
if (DoResolveBaseType)
{
var bts = TypeDeclarationResolver.Resolve(v.Type, ctxt);
if (bts != null && bts.Length != 0 && ctxt.CheckForSingleResult(bts, v.Type))
bt = bts[0];
// For auto variables, use the initializer to get its type
else if (v.Initializer != null)
bt = ExpressionSemantics.Evaluation.EvaluateType(v.Initializer, ctxt);
// Check if inside an foreach statement header
if (bt == null && ctxt.ScopedStatement != null)
bt = GetForeachIteratorType(v, ctxt);
}
// Note: Also works for aliases! In this case, we simply try to resolve the aliased type, otherwise the variable's base type
ret=v.IsAlias ?
(DSymbol)new AliasedType(v, bt, typeBase as ISyntaxRegion) :
new MemberSymbol(v, bt, typeBase as ISyntaxRegion);
}
else if (m is DMethod)
{
ret = new MemberSymbol((DNode)m,
DoResolveBaseType ? GetMethodReturnType((DMethod)m, ctxt) : null
, typeBase as ISyntaxRegion);
}
else if (m is DClassLike)
{
UserDefinedType udt = null;
var dc=(DClassLike)m;
switch (dc.ClassType)
{
case DTokens.Struct:
udt = new StructType(dc, typeBase as ISyntaxRegion);
break;
case DTokens.Union:
udt = new UnionType(dc, typeBase as ISyntaxRegion);
break;
case DTokens.Class:
udt = new ClassType(dc, typeBase as ISyntaxRegion, null);
break;
case DTokens.Template:
udt = new TemplateType(dc, typeBase as ISyntaxRegion);
break;
case DTokens.Interface:
udt = new InterfaceType(dc, typeBase as ISyntaxRegion);
break;
default:
ctxt.LogError(new ResolutionError(m, "Unknown type ("+DTokens.GetTokenString(dc.ClassType)+")"));
break;
}
if (canResolveBaseGenerally && !ctxt.Options.HasFlag(ResolutionOptions.DontResolveBaseClasses))
ret = DResolver.ResolveBaseClasses(udt, ctxt);
else
ret = udt;
}
else if (m is IAbstractSyntaxTree)
{
var mod = (IAbstractSyntaxTree)m;
if (typeBase != null && typeBase.ToString() != mod.ModuleName)
{
var pack = ctxt.ParseCache.LookupPackage(typeBase.ToString()).First();
if (pack != null)
ret = new PackageSymbol(pack, typeBase as ISyntaxRegion);
}
else
ret = new ModuleSymbol(m as DModule, typeBase as ISyntaxRegion);
}
else if (m is DEnum)
ret = new EnumType((DEnum)m, typeBase as ISyntaxRegion);
else if (m is TemplateParameterNode)
{
var tmp = ((TemplateParameterNode)m).TemplateParameter;
//ResolveResult[] templateParameterType = null;
//TODO: Resolve the specialization type
//var templateParameterType = TemplateInstanceHandler.ResolveTypeSpecialization(tmp, ctxt);
ret = new MemberSymbol((DNode)m, null, typeBase as ISyntaxRegion);
}
if (canResolveBaseGenerally && resultBase is DSymbol)
ctxt.CurrentContext.RemoveParamTypesFromPreferredLocals((DSymbol)resultBase);
if (popAfterwards)
ctxt.Pop();
stackNum_HandleNodeMatch--;
return ret;
}
public ISymbolValue VisitAliasedType(AliasedType t)
{
throw new NotImplementedException();
}
public ISymbolValue VisitAliasedType(AliasedType at)
{
return(VisitMemberSymbol(at)); // ?
}
