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); }