bool HandleDecl(TemplateTypeParameter p, IdentifierDeclaration id, ISemantic r)
{
// Bottom-level reached
if (id.InnerDeclaration == null && Contains(id.IdHash) && !id.ModuleScoped)
{
// Associate template param with r
return Set((p != null && id.IdHash == p.NameHash) ? p : null, r, id.IdHash);
}
var deducee = DResolver.StripMemberSymbols(AbstractType.Get(r)) as DSymbol;
if (id.InnerDeclaration != null && deducee != null && deducee.Definition.NameHash == id.IdHash)
{
var physicalParentType = TypeDeclarationResolver.HandleNodeMatch(deducee.Definition.Parent, ctxt, null, id.InnerDeclaration);
if (HandleDecl(p, id.InnerDeclaration, physicalParentType))
{
if (Contains(id.IdHash))
Set((p != null && id.IdHash == p.NameHash) ? p : null, deducee, id.IdHash);
return true;
}
}
/*
* If not stand-alone identifier or is not required as template param, resolve the id and compare it against r
*/
var _r = TypeDeclarationResolver.ResolveSingle(id, ctxt);
return _r != null && (EnforceTypeEqualityWhenDeducing ?
ResultComparer.IsEqual(r,_r) :
ResultComparer.IsImplicitlyConvertible(r,_r));
}
public static AbstractType Demangle(string mangledString, ResolutionContext ctxt, out ITypeDeclaration qualifier, out bool isCFunction)
{
if(string.IsNullOrEmpty(mangledString))
throw new ArgumentException("input string must not be null or empty!");
if (!mangledString.StartsWith("_D"))
{
isCFunction = true;
if (mangledString.StartsWith ("__D"))
mangledString = mangledString.Substring (1);
// C Functions
else if (mangledString.StartsWith ("_")) {
qualifier = new IdentifierDeclaration (mangledString.Substring (1));
return null;
}
}
//TODO: What about C functions that start with 'D'?
isCFunction = false;
var dmng = new Demangler(mangledString) { ctxt = ctxt };
return dmng.MangledName(out qualifier);
}
public static void Run()
{
Parse ();
var pcw = new LegacyParseCacheView (new[]{ srcDir });
var ctxt = new ResolutionContext (pcw, new ConditionalCompilationFlags(versions,0, true));
var mod = pcw.LookupModuleName (null, "botan.pubkey.algo.dsa").First();
var scope = ResolutionTests.N<DMethod> (mod, "DSAVerificationOperation.verify");
var scopedStmt = ResolutionTests.S (scope, 9);
ctxt.Push (scope, scopedStmt.Location);
ITypeDeclaration td = new IdentifierDeclaration ("q"){ Location = scopedStmt.Location };
AbstractType t;
var sw = new Stopwatch ();
Console.WriteLine ("Begin resolving...");
sw.Restart ();
t = TypeDeclarationResolver.ResolveSingle(td, ctxt);
sw.Stop ();
Console.WriteLine ("Finished resolution. {0} ms.", sw.ElapsedMilliseconds);
sw.Restart ();
t = TypeDeclarationResolver.ResolveSingle(td, ctxt);
sw.Stop ();
Console.WriteLine ("Finished resolution. {0} ms.", sw.ElapsedMilliseconds);
}
public static AbstractType getStringType(ResolverContextStack ctxt)
{
var str = new IdentifierDeclaration("string");
var sType = TypeDeclarationResolver.Resolve(str, ctxt);
ctxt.CheckForSingleResult(sType, str);
return sType != null && sType.Length != 0 ? sType[0] : null;
}
public ImportSymbolAlias(ImportStatement impStmt, ImportStatement.ImportBinding imp, IBlockNode parentNode)
: base(impStmt, parentNode)
{
ImportBinding = imp;
var sym = imp.Symbol;
Name = (imp.Alias ?? sym).Id;
NameLocation = (imp.Alias ?? sym).Location;
Location = imp.Symbol.Location;
Type = new IdentifierDeclaration(sym.Id)
{
Location = sym.Location,
EndLocation = sym.EndLocation,
InnerDeclaration = impStmt.ImportBindList.Module.ModuleIdentifier
};
}
static ResolveResult[] HandleIdDeclaration(IdentifierDeclaration typeId,
ResolverContext lastResCtxt,
IAbstractSyntaxTree SyntaxTree,
CodeScanResult csr,
Dictionary<string, ResolveResult> compDict)
{
var typeString = typeId.ToString();
bool WasAlreadyResolved = false;
ResolveResult[] allCurrentResults = null;
ResolveResult rr = null;
/*
* string,wstring,dstring are highlighted by the editor's syntax definition automatically..
* Anyway, allow to resolve e.g. "object.string"
*/
if (typeString == "" || typeString == "string" || typeString == "wstring" || typeString == "dstring")
return null;
lastResCtxt.ScopedBlock = DResolver.SearchBlockAt(SyntaxTree, typeId.Location, out lastResCtxt.ScopedStatement);
if (typeString == "th" && typeId.Location.Line == 114)
{
}
if (!(WasAlreadyResolved = compDict.TryGetValue(typeString, out rr)))
{
allCurrentResults = DResolver.ResolveType(typeId, lastResCtxt);
if (allCurrentResults != null && allCurrentResults.Length > 0)
rr = allCurrentResults[0];
}
if (rr == null)
{
if (typeId is IdentifierDeclaration)
csr.UnresolvedIdentifiers.Add(typeId as IdentifierDeclaration);
}
else
{
/*
* Note: It is of course possible to highlight more than one type in one type declaration!
* So, we scan down the result hierarchy for TypeResults and highlight all of them later.
*/
var curRes = rr;
/*
* Note: Since we want to use results multiple times,
* we at least have to 'update' their type declarations
* to ensure that the second, third, fourth etc. occurence of this result
* are also highlit (and won't(!) cause an Already-Added-Exception of our finalDict-Array)
*/
var curTypeDeclBase = typeId as ITypeDeclaration;
while (curRes != null)
{
if (curRes is MemberResult)
{
var mr = curRes as MemberResult;
// If curRes is an alias or a template parameter, highlight it
if (mr.ResolvedMember is TemplateParameterNode ||
(mr.ResolvedMember is DVariable &&
(mr.ResolvedMember as DVariable).IsAlias))
{
try
{
csr.ResolvedIdentifiers.Add(curTypeDeclBase as IdentifierDeclaration, curRes);
}
catch { }
// See performance reasons
//if (curRes != rr && !WasAlreadyResolved && !) compDict.Add(curTypeDeclBase.ToString(), curRes);
}
}
else if (curRes is TypeResult)
{
// Yeah, in quite all cases we do identify a class via its name ;-)
if (curTypeDeclBase is IdentifierDeclaration &&
!(curTypeDeclBase is DTokenDeclaration) &&
!csr.ResolvedIdentifiers.ContainsKey(curTypeDeclBase as IdentifierDeclaration))
{
csr.ResolvedIdentifiers.Add(curTypeDeclBase as IdentifierDeclaration, curRes);
// See performance reasons
//if (curRes != rr && !WasAlreadyResolved) compDict.Add(curTypeDeclBase.ToString(), curRes);
}
}
else if (curRes is ModuleResult)
{
if (curTypeDeclBase is IdentifierDeclaration &&
!csr.ResolvedIdentifiers.ContainsKey(curTypeDeclBase as IdentifierDeclaration))
csr.ResolvedIdentifiers.Add(curTypeDeclBase as IdentifierDeclaration, curRes);
}
curRes = curRes.ResultBase;
curTypeDeclBase = curTypeDeclBase.InnerDeclaration;
}
}
return allCurrentResults;
}
ISemantic E(UnaryExpression_Type x)
{
var uat = x as UnaryExpression_Type;
if (uat.Type == null)
return null;
var types = TypeDeclarationResolver.Resolve(uat.Type, ctxt);
ctxt.CheckForSingleResult(types, uat.Type);
if (types != null && types.Length != 0)
{
var id = new IdentifierDeclaration(uat.AccessIdentifier) { EndLocation = uat.EndLocation };
// First off, try to resolve static properties
var statProp = StaticPropertyResolver.TryResolveStaticProperties(types[0], uat.AccessIdentifier, ctxt, eval, id);
if (statProp != null)
return statProp;
// If it's not the case, try the conservative way
var res = TypeDeclarationResolver.Resolve(id, ctxt, types);
ctxt.CheckForSingleResult(res, x);
if (res != null && res.Length != 0)
return res[0];
}
return null;
}
public static ArgumentsResolutionResult ResolveArgumentContext(
string code,
int caretOffset,
CodeLocation caretLocation,
DMethod MethodScope,
IEnumerable<IAbstractSyntaxTree> parseCache, IEnumerable<IAbstractSyntaxTree> ImportCache)
{
var ctxt = new ResolverContext { ScopedBlock = MethodScope, ParseCache = parseCache, ImportCache=ImportCache };
#region Parse the code between the last block opener and the caret
var curMethodBody = MethodScope.GetSubBlockAt(caretLocation);
if (curMethodBody == null && MethodScope.Parent is DMethod)
{
MethodScope = MethodScope.Parent as DMethod;
curMethodBody = MethodScope.GetSubBlockAt(caretLocation);
}
if (curMethodBody == null)
return null;
var blockOpenerLocation = curMethodBody.StartLocation;
var blockOpenerOffset = blockOpenerLocation.Line <= 0 ? blockOpenerLocation.Column :
DocumentHelper.LocationToOffset(code, blockOpenerLocation);
if (blockOpenerOffset >= 0 && caretOffset - blockOpenerOffset > 0)
{
var codeToParse = code.Substring(blockOpenerOffset, caretOffset - blockOpenerOffset);
curMethodBody = DParser.ParseBlockStatement(codeToParse, blockOpenerLocation, MethodScope);
if (curMethodBody != null)
ctxt.ScopedStatement = curMethodBody.SearchStatementDeeply(caretLocation);
}
if (curMethodBody == null || ctxt.ScopedStatement == null)
return null;
#endregion
// Scan statement for method calls or template instantiations
var e = DResolver.SearchForMethodCallsOrTemplateInstances(ctxt.ScopedStatement, caretLocation);
/*
* 1) foo( -- normal arguments only
* 2) foo!(...)( -- normal arguments + template args
* 3) foo!( -- template args only
* 4) new myclass( -- ctor call
* 5) new myclass!( -- ditto
* 6) new myclass!(...)(
* 7) mystruct( -- opCall call
*/
var res = new ArgumentsResolutionResult() { ParsedExpression = e };
ITypeDeclaration methodIdentifier = null;
// 1), 2)
if (e is PostfixExpression_MethodCall)
{
res.IsMethodArguments = true;
var call = e as PostfixExpression_MethodCall;
if (call.Arguments != null)
{
int i = 0;
foreach (var arg in call.Arguments)
{
if (caretLocation >= arg.Location && caretLocation <= arg.EndLocation)
{
res.CurrentlyTypedArgumentIndex = i;
break;
}
i++;
}
}
methodIdentifier = call.PostfixForeExpression.ExpressionTypeRepresentation;
}
// 3)
else if (e is TemplateInstanceExpression)
{
var templ = e as TemplateInstanceExpression;
res.IsTemplateInstanceArguments = true;
if (templ.Arguments != null)
{
int i = 0;
foreach (var arg in templ.Arguments)
{
if (caretLocation >= arg.Location && caretLocation <= arg.EndLocation)
{
res.CurrentlyTypedArgumentIndex = i;
break;
}
i++;
}
}
methodIdentifier = new IdentifierDeclaration(templ.TemplateIdentifier.Value) { InnerDeclaration=templ.InnerDeclaration };
}
else if (e is NewExpression)
{
var ne = e as NewExpression;
if (ne.Arguments != null)
{
int i = 0;
foreach (var arg in ne.Arguments)
{
if (caretLocation >= arg.Location && caretLocation <= arg.EndLocation)
{
res.CurrentlyTypedArgumentIndex = i;
break;
}
i++;
}
}
methodIdentifier = ne.ExpressionTypeRepresentation;
}
if (methodIdentifier == null)
return null;
// Resolve all types, methods etc. which belong to the methodIdentifier
res.ResolvedTypesOrMethods = ResolveType(methodIdentifier, ctxt);
if (res.ResolvedTypesOrMethods == null)
return res;
// 4),5),6)
if (e is NewExpression)
{
var substitutionList = new List<ResolveResult>();
foreach (var rr in res.ResolvedTypesOrMethods)
if (rr is TypeResult)
{
var classDef = (rr as TypeResult).ResolvedTypeDefinition as DClassLike;
if (classDef == null)
continue;
//TODO: Regard protection attributes for ctor members
foreach (var i in classDef)
if (i is DMethod && (i as DMethod).SpecialType == DMethod.MethodType.Constructor)
substitutionList.Add(HandleNodeMatch(i, ctxt, resultBase: rr));
}
if (substitutionList.Count > 0)
res.ResolvedTypesOrMethods = substitutionList.ToArray();
}
// 7)
else if (e is PostfixExpression_MethodCall)
{
var substitutionList = new List<ResolveResult>();
var nonAliases=TryRemoveAliasesFromResult(res.ResolvedTypesOrMethods);
foreach (var rr in nonAliases)
if (rr is TypeResult)
{
var classDef = (rr as TypeResult).ResolvedTypeDefinition as DClassLike;
if (classDef == null)
continue;
//TODO: Regard protection attributes for opCall members
foreach (var i in classDef)
if (i is DMethod && i.Name == "opCall")
substitutionList.Add(HandleNodeMatch(i, ctxt, resultBase: rr));
}
if (substitutionList.Count > 0)
nonAliases = substitutionList.ToArray();
res.ResolvedTypesOrMethods = nonAliases;
}
return res;
}
public TemplateInstanceExpression TemplateInstance(IBlockNode Scope)
{
var loc = la.Location;
var mod = INVALID;
if (DTokens.IsStorageClass(laKind)) {
mod = laKind;
Step ();
}
if (!Expect (Identifier))
return null;
ITypeDeclaration td = new IdentifierDeclaration (t.Value) {
Location = t.Location,
EndLocation = t.EndLocation
};
td = new TemplateInstanceExpression(mod != DTokens.INVALID ? new MemberFunctionAttributeDecl(mod) { InnerType = td } : td) {
Location = loc
};
var args = new List<IExpression>();
if (!Expect(Not))
return td as TemplateInstanceExpression;
if (laKind == (OpenParenthesis))
{
Step();
if (laKind != CloseParenthesis)
{
bool init = true;
while (laKind == Comma || init)
{
if (!init) Step();
init = false;
if (laKind == CloseParenthesis)
break;
Lexer.PushLookAheadBackup();
bool wp = AllowWeakTypeParsing;
AllowWeakTypeParsing = true;
var typeArg = Type();
AllowWeakTypeParsing = wp;
if (typeArg != null && (laKind == CloseParenthesis || laKind==Comma)){
Lexer.PopLookAheadBackup();
args.Add(new TypeDeclarationExpression(typeArg));
}else
{
Lexer.RestoreLookAheadBackup();
args.Add(AssignExpression(Scope));
}
}
}
Expect(CloseParenthesis);
}
else
{
/*
* TemplateSingleArgument:
* Identifier
* BasicTypeX
* CharacterLiteral
* StringLiteral
* IntegerLiteral
* FloatLiteral
* true
* false
* null
* this
* __FILE__
* __MODULE__
* __LINE__
* __FUNCTION__
* __PRETTY_FUNCTION__
*/
switch (laKind)
{
case Literal:
case True:
case False:
case Null:
case This:
case __FILE__:
case __MODULE__:
case __LINE__:
case __FUNCTION__:
case __PRETTY_FUNCTION__:
args.Add(PrimaryExpression(Scope));
break;
case Identifier:
Step();
args.Add(new IdentifierExpression(t.Value) {
Location = t.Location,
EndLocation = t.EndLocation
});
break;
default:
if (IsBasicType(laKind))
{
Step ();
args.Add (new TypeDeclarationExpression (new DTokenDeclaration (t.Kind) {
Location = t.Location,
EndLocation = t.EndLocation
}));
break;
}
else if (IsEOF)
goto case Literal;
SynErr(laKind, "Illegal token found on template instance expression argument");
Step();
break;
}
if (laKind == Not && Peek(1).Kind != Is && Peek(1).Kind != In)
{
SynErr(laKind, "multiple ! arguments are not allowed");
Step();
}
}
(td as TemplateInstanceExpression).Arguments = args.ToArray();
td.EndLocation = t.EndLocation;
return td as TemplateInstanceExpression;
}
public override void Visit(IdentifierDeclaration id)
{
var resolvedSymbol = TryPopPFAStack ();
if (id.IdHash == searchHash) {
if(resolvedSymbol == null)
resolvedSymbol = TypeDeclarationResolver.ResolveSingle (id, ctxt) as DSymbol;
if (resolvedSymbol != null && resolvedSymbol.Definition == symbol) {
l.Add (id);
return;
}
}
base.Visit (id);
}
ImportStatement.ImportBindings ImportBindings(ImportStatement.Import imp)
{
var importBindings = new ImportStatement.ImportBindings { Module=imp };
LastParsedObject = importBindings;
bool init = true;
while (laKind == Comma || init)
{
if (init)
init = false;
else
Step();
if (Expect(Identifier))
{
var symbolAlias = new IdentifierDeclaration(t.Value){ Location = t.Location, EndLocation = t.EndLocation };
if (laKind == Assign)
{
Step();
if (Expect (Identifier))
importBindings.SelectedSymbols.Add (new ImportStatement.ImportBinding (new IdentifierDeclaration (t.Value) {
Location = t.Location,
EndLocation = t.EndLocation
}, symbolAlias));
}
else
importBindings.SelectedSymbols.Add(new ImportStatement.ImportBinding(symbolAlias));
}
}
if (!IsEOF)
LastParsedObject = null;
return importBindings;
}
public virtual void Visit(IdentifierDeclaration td)
{
VisitInner(td);
}
public static AbstractType ResolveKey(ArrayDecl ad, out int fixedArrayLength, out ISymbolValue keyVal, ResolutionContext ctxt)
{
keyVal = null;
fixedArrayLength = -1;
AbstractType keyType = null;
if (ad.KeyExpression != null)
{
//TODO: Template instance expressions?
var id_x = ad.KeyExpression as IdentifierExpression;
if (id_x != null && id_x.IsIdentifier)
{
var id = new IdentifierDeclaration((string)id_x.Value)
{
Location = id_x.Location,
EndLocation = id_x.EndLocation
};
keyType = TypeDeclarationResolver.ResolveSingle(id, ctxt);
if (keyType != null)
{
var tt = DResolver.StripAliasSymbol(keyType) as MemberSymbol;
if (tt == null ||
!(tt.Definition is DVariable) ||
((DVariable)tt.Definition).Initializer == null)
return keyType;
}
}
try
{
keyVal = Evaluation.EvaluateValue(ad.KeyExpression, ctxt);
if (keyVal != null)
{
// Take the value's type as array key type
keyType = keyVal.RepresentedType;
// It should be mostly a number only that points out how large the final array should be
var pv = Evaluation.GetVariableContents(keyVal, new StandardValueProvider(ctxt)) as PrimitiveValue;
if (pv != null)
{
fixedArrayLength = System.Convert.ToInt32(pv.Value);
if (fixedArrayLength < 0)
ctxt.LogError(ad, "Invalid array size: Length value must be greater than 0");
}
//TODO Is there any other type of value allowed?
}
}
catch { }
}
else
{
var t = Resolve(ad.KeyType, ctxt);
ctxt.CheckForSingleResult(t, ad.KeyType);
if (t != null && t.Length != 0)
return t[0];
}
return keyType;
}
public static AbstractType[] Resolve(IdentifierDeclaration id, ResolutionContext ctxt, AbstractType[] resultBases = null, bool filterForTemplateArgs = true)
{
AbstractType[] res;
if (id.InnerDeclaration == null && resultBases == null)
res = ResolveIdentifier(id.IdHash, ctxt, id, id.ModuleScoped);
else
{
var rbases = resultBases ?? Resolve(id.InnerDeclaration, ctxt);
if (rbases == null || rbases.Length == 0)
return null;
res = ResolveFurtherTypeIdentifier(id.IdHash, rbases, ctxt, id);
}
if (filterForTemplateArgs && (ctxt.Options & ResolutionOptions.NoTemplateParameterDeduction) == 0)
{
var l_ = new List<AbstractType>();
if (res != null)
foreach (var s in res)
l_.Add(s);
return TemplateInstanceHandler.DeduceParamsAndFilterOverloads(l_, null, false, ctxt);
}
else
return res;
}
public ImportBinding(IdentifierDeclaration symbol, IdentifierDeclaration alias = null)
{
Symbol = symbol;
Alias = alias;
}
bool HandleDecl(TemplateTypeParameter p, IdentifierDeclaration id, ISemantic r)
{
// Bottom-level reached
if (id.InnerDeclaration == null && Contains(id.Id) && !id.ModuleScoped)
{
// Associate template param with r
return Set(p, r, id.Id);
}
/*
* If not stand-alone identifier or is not required as template param, resolve the id and compare it against r
*/
var _r = TypeDeclarationResolver.Resolve(id, ctxt);
ctxt.CheckForSingleResult(_r, id);
return _r != null && _r.Length != 0 &&
(EnforceTypeEqualityWhenDeducing ?
ResultComparer.IsEqual(r,_r[0]) :
ResultComparer.IsImplicitlyConvertible(r,_r[0]));
}
public override void Visit(IdentifierDeclaration td)
{
if (td.IdHash == DTokens.IncompleteIdHash) {
halt = true;
if(td.InnerDeclaration != null)
prv = new MemberCompletionProvider (cdgen, td.InnerDeclaration, scopedBlock, scopedStatement);
}
else
base.Visit (td);
}
public override void Visit (IdentifierDeclaration id)
{
if (id.IdHash == searchHash || resolveAnyway) {
ctxt.CurrentContext.Set(id.Location);
if (TryAdd(TypeDeclarationResolver.ResolveSingle(id, ctxt), id))
return;
}
base.Visit (id);
}
/// <summary>
/// See <see cref="Resolve"/>
/// </summary>
public static AbstractType ResolveSingle(IdentifierDeclaration id, ResolutionContext ctxt, AbstractType[] resultBases = null, bool filterForTemplateArgs = true)
{
var r = Resolve(id, ctxt, resultBases, filterForTemplateArgs);
ctxt.CheckForSingleResult(r, id);
return r != null && r.Length != 0 ? r[0] : null;
}
public TemplateInstanceExpression TemplateInstance(IBlockNode Scope)
{
var loc = la.Location;
var mod = INVALID;
if (DTokens.StorageClass [laKind]) {
mod = laKind;
Step ();
}
if (!Expect (Identifier))
return null;
ITypeDeclaration td = new IdentifierDeclaration (t.Value) {
Location = t.Location,
EndLocation = t.EndLocation
};
td = new TemplateInstanceExpression(mod != DTokens.INVALID ? new MemberFunctionAttributeDecl(mod) { InnerType = td } : td) {
Location = loc
};
LastParsedObject = td;
var args = new List<IExpression>();
if (!Expect(Not))
return td as TemplateInstanceExpression;
if (laKind == (OpenParenthesis))
{
Step();
if (laKind != CloseParenthesis)
{
bool init = true;
while (laKind == Comma || init)
{
if (!init) Step();
init = false;
if (laKind == CloseParenthesis)
break;
if (IsEOF)
{
args.Add(new TokenExpression(DTokens.INVALID) { Location= la.Location, EndLocation=la.EndLocation });
break;
}
Lexer.PushLookAheadBackup();
bool wp = AllowWeakTypeParsing;
AllowWeakTypeParsing = true;
var typeArg = Type();
AllowWeakTypeParsing = wp;
if (typeArg != null && (laKind == CloseParenthesis || laKind==Comma)){
Lexer.PopLookAheadBackup();
args.Add(new TypeDeclarationExpression(typeArg));
}else
{
Lexer.RestoreLookAheadBackup();
args.Add(AssignExpression(Scope));
}
}
}
Expect(CloseParenthesis);
}
else
{
Step();
/*
* TemplateSingleArgument:
* Identifier
* BasicTypeX
* CharacterLiteral
* StringLiteral
* IntegerLiteral
* FloatLiteral
* true
* false
* null
* __FILE__
* __LINE__
*/
IExpression arg= null;
if (t.Kind == Literal)
arg = new IdentifierExpression(t.LiteralFormat == LiteralFormat.StringLiteral ||
t.LiteralFormat == LiteralFormat.VerbatimStringLiteral ?
t.Value :
t.LiteralValue,
t.LiteralFormat,
t.Subformat)
{
Location = t.Location,
EndLocation = t.EndLocation
};
else if (t.Kind == Identifier)
arg = new IdentifierExpression(t.Value)
{
Location = t.Location,
EndLocation = t.EndLocation
};
else if (BasicTypes[t.Kind])
arg = new TypeDeclarationExpression(new DTokenDeclaration(t.Kind)
{
Location = t.Location,
EndLocation = t.EndLocation
});
else if (
t.Kind == True ||
t.Kind == False ||
t.Kind == Null ||
t.Kind == __FILE__ ||
t.Kind == __LINE__)
arg = new TokenExpression(t.Kind)
{
Location = t.Location,
EndLocation = t.EndLocation
};
else if (IsEOF)
{
TrackerVariables.ExpectingIdentifier = false;
td.EndLocation = CodeLocation.Empty;
return td as TemplateInstanceExpression;
}
args.Add(arg);
}
(td as TemplateInstanceExpression).Arguments = args.ToArray();
td.EndLocation = t.EndLocation;
return td as TemplateInstanceExpression;
}
/// <summary>
/// Tries to resolve a static property's name.
/// Returns a result describing the theoretical member (".init"-%gt;MemberResult; ".typeof"->TypeResult etc).
/// Returns null if nothing was found.
/// </summary>
/// <param name="InitialResult"></param>
/// <returns></returns>
public static MemberSymbol TryResolveStaticProperties(
ISemantic InitialResult,
string propertyIdentifier,
ResolverContextStack ctxt = null,
bool Evaluate = false,
IdentifierDeclaration idContainter = null)
{
// If a pointer'ed type is given, take its base type
if (InitialResult is PointerType)
InitialResult = ((PointerType)InitialResult).Base;
if (InitialResult == null || InitialResult is ModuleSymbol)
return null;
INode relatedNode = null;
if (InitialResult is DSymbol)
relatedNode = ((DSymbol)InitialResult).Definition;
#region init
if (propertyIdentifier == "init")
{
var prop_Init = new DVariable
{
Name = "init",
Description = "Initializer"
};
if (relatedNode != null)
{
if (!(relatedNode is DVariable))
{
prop_Init.Parent = relatedNode.Parent;
prop_Init.Type = new IdentifierDeclaration(relatedNode.Name);
}
else
{
prop_Init.Parent = relatedNode;
prop_Init.Initializer = (relatedNode as DVariable).Initializer;
prop_Init.Type = relatedNode.Type;
}
}
return new MemberSymbol(prop_Init, DResolver.StripAliasSymbol(AbstractType.Get(InitialResult)), idContainter);
}
#endregion
#region sizeof
if (propertyIdentifier == "sizeof")
return new MemberSymbol(new DVariable
{
Name = "sizeof",
Type = new DTokenDeclaration(DTokens.Int),
Initializer = new IdentifierExpression(4),
Description = "Size in bytes (equivalent to C's sizeof(type))"
}, new PrimitiveType(DTokens.Int), idContainter);
#endregion
#region alignof
if (propertyIdentifier == "alignof")
return new MemberSymbol(new DVariable
{
Name = "alignof",
Type = new DTokenDeclaration(DTokens.Int),
Description = "Alignment size"
}, new PrimitiveType(DTokens.Int),idContainter);
#endregion
#region mangleof
if (propertyIdentifier == "mangleof")
return new MemberSymbol(new DVariable
{
Name = "mangleof",
Type = new IdentifierDeclaration("string"),
Description = "String representing the ‘mangled’ representation of the type"
}, getStringType(ctxt) , idContainter);
#endregion
#region stringof
if (propertyIdentifier == "stringof")
return new MemberSymbol(new DVariable
{
Name = "stringof",
Type = new IdentifierDeclaration("string"),
Description = "String representing the source representation of the type"
}, getStringType(ctxt), idContainter);
#endregion
#region classinfo
else if (propertyIdentifier == "classinfo")
{
var tr = DResolver.StripMemberSymbols(AbstractType.Get(InitialResult)) as TemplateIntermediateType;
if (tr is ClassType || tr is InterfaceType)
{
var ci=new IdentifierDeclaration("TypeInfo_Class")
{
InnerDeclaration = new IdentifierDeclaration("object"),
ExpressesVariableAccess = true,
};
var ti = TypeDeclarationResolver.Resolve(ci, ctxt);
ctxt.CheckForSingleResult(ti, ci);
return new MemberSymbol(new DVariable { Name = "classinfo", Type = ci }, ti!=null && ti.Length!=0?ti[0]:null, idContainter);
}
}
#endregion
//TODO: Resolve the types of type-specific properties (floats, ints, arrays, assocarrays etc.)
return null;
}
ITypeDeclaration ModuleFullyQualifiedName()
{
if (!Expect(Identifier))
return null;
var td = new IdentifierDeclaration(t.Value) { Location=t.Location,EndLocation=t.EndLocation };
while (laKind == Dot)
{
Step();
Expect(Identifier);
td = new IdentifierDeclaration(t.Value) { Location=t.Location, EndLocation=t.EndLocation, InnerDeclaration = td };
}
return td;
}
public ITypeDeclaration IdentifierList()
{
ITypeDeclaration td = null;
bool notInit = false;
do
{
if (notInit)
Step();
else
notInit = true;
ITypeDeclaration ttd;
if (IsTemplateInstance)
ttd = TemplateInstance(null);
else if (Expect(Identifier))
ttd = new IdentifierDeclaration(t.Value) { Location = t.Location, EndLocation = t.EndLocation };
else if (IsEOF)
return new DTokenDeclaration(DTokens.Incomplete, td);
else
ttd = null;
if (ttd != null)
ttd.InnerDeclaration = td;
td = ttd;
}
while (laKind == Dot);
return td;
}
public virtual void Visit(IdentifierDeclaration td)
{
VisitInner(td);
}
ITypeDeclaration QualifiedName()
{
ITypeDeclaration td = null;
int n;
while(PeekIsDecNumber)
{
// Read number of either the first LName or TemplateInstanceName
n = (int)Number();
sb.Clear();
if((char)r.Peek() == '_')
{
r.Read();
sb.Append('_');
if((char)r.Peek() == '_')
{
r.Read();
sb.Append('_');
if((char)r.Peek() == 'T')
{
r.Read();
// We've got to handle a Template instance:
// Number __T LName TemplateArgs Z
var tpi = new TemplateInstanceExpression(new IdentifierDeclaration(LName()));
tpi.InnerDeclaration = td;
td = tpi;
var xx = new List<IExpression>();
while(r.Peek() != -1)
{
var arg = TemplateArg();
if(arg == null)
break;
xx.Add(arg);
}
tpi.Arguments = xx.ToArray();
continue;
}
}
}
// Just an LName
if(n > sb.Length)
sb.Append(LName(n-sb.Length));
var ttd = new IdentifierDeclaration(sb.ToString());
ttd.InnerDeclaration = td;
td = ttd;
}
return td;
}
ITypeDeclaration ModuleFullyQualifiedName()
{
if (!Expect (Identifier))
return IsEOF ? new DTokenDeclaration(DTokens.Incomplete) : null;
var td = new IdentifierDeclaration(t.Value) { Location=t.Location,EndLocation=t.EndLocation };
while (laKind == Dot)
{
Step();
if(Expect(Identifier))
td = new IdentifierDeclaration(t.Value) { Location=t.Location, EndLocation=t.EndLocation, InnerDeclaration = td };
else if(IsEOF)
td = new IdentifierDeclaration(DTokens.IncompleteIdHash) { InnerDeclaration = td };
}
return td;
}
/// <summary>
/// Tries to resolve a static property's name.
/// Returns a result describing the theoretical member (".init"-%gt;MemberResult; ".typeof"->TypeResult etc).
/// Returns null if nothing was found.
/// </summary>
/// <param name="InitialResult"></param>
/// <returns></returns>
public static ResolveResult TryResolveStaticProperties(ResolveResult InitialResult, IdentifierDeclaration Identifier, ResolverContext ctxt = null)
{
if (InitialResult == null || Identifier == null || InitialResult is ModuleResult)
{
return null;
}
var propertyName = Identifier.Value as string;
if (propertyName == null)
return null;
INode relatedNode = null;
if (InitialResult is MemberResult)
relatedNode = (InitialResult as MemberResult).ResolvedMember;
else if (InitialResult is TypeResult)
relatedNode = (InitialResult as TypeResult).ResolvedTypeDefinition;
#region init
if (propertyName == "init")
{
var prop_Init = new DVariable
{
Name = "init",
Description = "Initializer"
};
if (relatedNode != null)
{
if (!(relatedNode is DVariable))
{
prop_Init.Parent = relatedNode.Parent;
prop_Init.Type = new IdentifierDeclaration(relatedNode.Name);
}
else
{
prop_Init.Parent = relatedNode;
prop_Init.Initializer = (relatedNode as DVariable).Initializer;
prop_Init.Type = relatedNode.Type;
}
}
return new MemberResult
{
ResultBase = InitialResult,
MemberBaseTypes = new[] { InitialResult },
TypeDeclarationBase = Identifier,
ResolvedMember = prop_Init
};
}
#endregion
#region sizeof
if (propertyName == "sizeof")
return new MemberResult
{
ResultBase = InitialResult,
TypeDeclarationBase = Identifier,
ResolvedMember = new DVariable
{
Name = "sizeof",
Type = new DTokenDeclaration(DTokens.Int),
Initializer = new IdentifierExpression(4),
Description = "Size in bytes (equivalent to C's sizeof(type))"
}
};
#endregion
#region alignof
if (propertyName == "alignof")
return new MemberResult
{
ResultBase = InitialResult,
TypeDeclarationBase = Identifier,
ResolvedMember = new DVariable
{
Name = "alignof",
Type = new DTokenDeclaration(DTokens.Int),
Description = "Alignment size"
}
};
#endregion
#region mangleof
if (propertyName == "mangleof")
return new MemberResult
{
ResultBase = InitialResult,
TypeDeclarationBase = Identifier,
ResolvedMember = new DVariable
{
Name = "mangleof",
Type = new IdentifierDeclaration("string"),
Description = "String representing the ‘mangled’ representation of the type"
},
MemberBaseTypes = ResolveType(new IdentifierDeclaration("string"), ctxt)
};
#endregion
#region stringof
if (propertyName == "stringof")
return new MemberResult
{
ResultBase = InitialResult,
TypeDeclarationBase = Identifier,
ResolvedMember = new DVariable
{
Name = "stringof",
Type = new IdentifierDeclaration("string"),
Description = "String representing the source representation of the type"
},
MemberBaseTypes = ResolveType(new IdentifierDeclaration("string"), ctxt)
};
#endregion
bool
isArray = false,
isAssocArray = false,
isInt = false,
isFloat = false;
#region See AbsractCompletionSupport.StaticPropertyAddition
if (InitialResult is StaticTypeResult)
{
var srr = InitialResult as StaticTypeResult;
var type = srr.TypeDeclarationBase;
// on things like immutable(char), pass by the surrounding attribute..
while (type is MemberFunctionAttributeDecl)
type = (type as MemberFunctionAttributeDecl).InnerType;
if (type is ArrayDecl)
{
var ad = type as ArrayDecl;
// Normal array
if (ad.KeyType is DTokenDeclaration && DTokens.BasicTypes_Integral[(ad.KeyType as DTokenDeclaration).Token])
isArray = true;
// Associative array
else
isAssocArray = true;
}
else if (!(type is PointerDecl))
{
int TypeToken = srr.BaseTypeToken;
if (TypeToken <= 0 && type is DTokenDeclaration)
TypeToken = (type as DTokenDeclaration).Token;
if (TypeToken > 0)
{
// Determine whether float by the var's base type
isInt = DTokens.BasicTypes_Integral[srr.BaseTypeToken];
isFloat = DTokens.BasicTypes_FloatingPoint[srr.BaseTypeToken];
}
}
}
else if (InitialResult is ExpressionResult)
{
var err = InitialResult as ExpressionResult;
var expr = err.Expression;
// 'Skip' surrounding parentheses
while (expr is SurroundingParenthesesExpression)
expr = (expr as SurroundingParenthesesExpression).Expression;
var idExpr = expr as IdentifierExpression;
if (idExpr != null)
{
// Char literals, Integrals types & Floats
if ((idExpr.Format & LiteralFormat.Scalar) == LiteralFormat.Scalar || idExpr.Format == LiteralFormat.CharLiteral)
{
// Floats also imply integral properties
isInt = true;
isFloat = (idExpr.Format & LiteralFormat.FloatingPoint) == LiteralFormat.FloatingPoint;
}
// String literals
else if (idExpr.Format == LiteralFormat.StringLiteral || idExpr.Format == LiteralFormat.VerbatimStringLiteral)
{
isArray = true;
}
}
// Pointer conversions (e.g. (myInt*).sizeof)
}
#endregion
//TODO: Resolve static [assoc] array props
if (isArray || isAssocArray)
{
}
return null;
}
public override void Visit(IdentifierDeclaration td)
{
byte type;
if (DoPrimaryIdCheck(td.IdHash, out type))
AddResult(td, type);
base.Visit (td);
}
public ITypeDeclaration IdentifierList()
{
ITypeDeclaration td = null;
bool init = true;
while (init|| laKind == Dot)
{
if(!init)
Step();
init = false;
ITypeDeclaration ttd = null;
if (IsTemplateInstance)
ttd = TemplateInstance();
else if (Expect(Identifier))
ttd = new IdentifierDeclaration(t.Value) { Location=t.Location, EndLocation=t.EndLocation };
if (ttd != null)
ttd.InnerDeclaration = td;
td = ttd;
}
ExpectingIdentifier = false;
return td;
}
public ITypeDeclaration IdentifierList(IBlockNode scope = null)
{
ITypeDeclaration td = null;
switch (laKind) {
case DTokens.This:
case DTokens.Super:
Step ();
td = new DTokenDeclaration (t.Kind) { Location = t.Location, EndLocation = t.EndLocation };
if (!Expect (DTokens.Dot))
return td;
break;
}
bool notInit = false;
do
{
if (notInit)
Step();
else
notInit = true;
ITypeDeclaration ttd;
if (IsTemplateInstance)
ttd = TemplateInstance(scope);
else if (Expect(Identifier))
ttd = new IdentifierDeclaration(t.Value) { Location = t.Location, EndLocation = t.EndLocation };
else if (IsEOF)
return new DTokenDeclaration(DTokens.Incomplete, td);
else
ttd = null;
if (ttd != null)
ttd.InnerDeclaration = td;
td = ttd;
}
while (laKind == Dot);
return td;
}
public override void Visit(IdentifierDeclaration td)
{
if (DoPrimaryIdCheck(td.IdHash))
AddResult(td);
base.Visit (td);
}