public AbstractType Visit(PostfixExpression_Access ex)
{
var r = Evaluation.EvalPostfixAccessExpression(this, ctxt, ex);
ctxt.CheckForSingleResult(r, ex);
return(r != null && r.Length != 0 ? r[0] : null);
}
void GetRawCallOverloads(ResolutionContext ctxt, IExpression callForeExpression,
out AbstractType[] baseExpression,
out TemplateInstanceExpression tix)
{
tix = null;
if (callForeExpression is PostfixExpression_Access)
{
var pac = (PostfixExpression_Access)callForeExpression;
tix = pac.AccessExpression as TemplateInstanceExpression;
baseExpression = Evaluation.EvalPostfixAccessExpression(this, ctxt, pac, null, false, false);
}
else
{
// Explicitly don't resolve the methods' return types - it'll be done after filtering to e.g. resolve template types to the deduced one
var optBackup = ctxt.CurrentContext.ContextDependentOptions;
ctxt.CurrentContext.ContextDependentOptions |= ResolutionOptions.DontResolveBaseTypes;
if (callForeExpression is TokenExpression)
{
baseExpression = ExpressionTypeEvaluation.GetResolvedConstructorOverloads((TokenExpression)callForeExpression, ctxt);
}
else
{
if (callForeExpression is TemplateInstanceExpression)
{
baseExpression = ExpressionTypeEvaluation.GetOverloads(tix = (TemplateInstanceExpression)callForeExpression, ctxt, null, false);
}
else if (callForeExpression is IdentifierExpression)
{
baseExpression = ExpressionTypeEvaluation.GetOverloads(callForeExpression as IdentifierExpression, ctxt, deduceParameters: false);
}
else
{
baseExpression = new[] { callForeExpression != null?AbstractType.Get(callForeExpression.Accept(this)) : null }
};
}
ctxt.CurrentContext.ContextDependentOptions = optBackup;
}
}
public AbstractType Visit(PostfixExpression_Access ex)
{
return(TryPretendMethodExecution(AmbiguousType.Get(Evaluation.EvalPostfixAccessExpression(this, ctxt, ex))));
}
public static AbstractType[] GetAccessedOverloads(PostfixExpression_Access acc, ResolutionContext ctxt,
ISemantic resultBase = null, bool DeducePostfixTemplateParams = true)
{
return(Evaluation.EvalPostfixAccessExpression <AbstractType>(new ExpressionTypeEvaluation(ctxt), ctxt, acc, resultBase, DeducePostfixTemplateParams));
}
public AbstractType Visit(TraitsExpression te)
{
PostfixExpression_Access pfa;
AbstractType t;
ResolutionOptions optionsBackup;
switch (te.Keyword)
{
case "":
case null:
return(null);
case "identifier":
return(GetStringType());
case "getMember":
pfa = prepareMemberTraitExpression(te, out t);
if (pfa == null || t == null)
{
break;
}
var vs = Evaluation.EvalPostfixAccessExpression(this, ctxt, pfa, t);
if (vs == null || vs.Length == 0)
{
return(null);
}
return(vs[0]);
case "getOverloads":
optionsBackup = ctxt.ContextIndependentOptions;
ctxt.ContextIndependentOptions = ResolutionOptions.IgnoreAllProtectionAttributes;
pfa = prepareMemberTraitExpression(te, out t);
if (pfa != null && t != null)
{
vs = Evaluation.EvalPostfixAccessExpression(this, ctxt, pfa, t);
}
else
{
vs = null;
}
ctxt.ContextIndependentOptions = optionsBackup;
return(new DTuple(te, vs));
case "getProtection":
return(GetStringType());
case "getVirtualFunctions":
break;
case "getVirtualMethods":
break;
case "parent":
break;
case "classInstanceSize":
break;
case "allMembers":
break;
case "derivedMembers":
break;
case "compiles":
return(new PrimitiveType(DTokens.Bool));
}
if (te.Keyword.StartsWith("is") || te.Keyword.StartsWith("has"))
{
return(new PrimitiveType(DTokens.Bool));
}
return(null);
}
