private bool AnalyzeMethodCallOnKnownType(Analyzer/*!*/ analyzer, ref ExInfoFromParent info, DType type) { if (type == null || type.IsUnknown) return false; bool runtimeVisibilityCheck, isCallMethod; routine = analyzer.ResolveMethod( type, qualifiedName.Name, Position, analyzer.CurrentType, analyzer.CurrentRoutine, false, out runtimeVisibilityCheck, out isCallMethod); if (routine.IsUnknown) return false; Debug.Assert(runtimeVisibilityCheck == false); // can only be set to true if CurrentType or CurrentRoutine are null // check __call if (isCallMethod) { // TODO: generic args var arg1 = new StringLiteral(this.Position, qualifiedName.Name.Value); var arg2 = this.callSignature.BuildPhpArray(); this.callSignature = new CallSignature( new List<ActualParam>(2) { new ActualParam(arg1.Position, arg1, false), new ActualParam(arg2.Position, arg2, false) }, new List<TypeRef>()); } // resolve overload if applicable: RoutineSignature signature; overloadIndex = routine.ResolveOverload(analyzer, callSignature, position, out signature); Debug.Assert(overloadIndex != DRoutine.InvalidOverloadIndex, "A function should have at least one overload"); // analyze parameters: callSignature.Analyze(analyzer, signature, info, false); // get properties: analyzer.AddCurrentRoutineProperty(routine.GetCallerRequirements()); return true; }
/// <summary> /// Analyze the method call (isMemberOf != null). /// </summary> /// <param name="analyzer"></param> /// <param name="info"></param> /// <returns></returns> private Evaluation AnalyzeMethodCall(Analyzer/*!*/ analyzer, ref ExInfoFromParent info) { Debug.Assert(isMemberOf != null); // $this-> DirectVarUse memberDirectVarUse = isMemberOf as DirectVarUse; if (memberDirectVarUse != null && memberDirectVarUse.IsMemberOf == null && // isMemberOf is single variable memberDirectVarUse.VarName.IsThisVariableName && // isMemberOf if $this analyzer.CurrentType != null) // called in class context of known type { // $this->{qualifiedName}(callSignature) bool runtimeVisibilityCheck, isCallMethod; routine = analyzer.ResolveMethod( analyzer.CurrentType,//typeof(this) qualifiedName.Name,//.Namespace? Position, analyzer.CurrentType, analyzer.CurrentRoutine, false, out runtimeVisibilityCheck, out isCallMethod); Debug.Assert(runtimeVisibilityCheck == false); // can only be set to true if CurrentType or CurrentRoutine are null if (!routine.IsUnknown) { // check __call if (isCallMethod) { // TODO: generic args var arg1 = new StringLiteral(this.Position, qualifiedName.Name.Value); var arg2 = this.callSignature.BuildPhpArray(); this.callSignature = new CallSignature( new List<ActualParam>(2) { new ActualParam(arg1.Position, arg1, false), new ActualParam(arg2.Position, arg2, false) }, new List<TypeRef>()); } // resolve overload if applicable: RoutineSignature signature; overloadIndex = routine.ResolveOverload(analyzer, callSignature, position, out signature); Debug.Assert(overloadIndex != DRoutine.InvalidOverloadIndex, "A function should have at least one overload"); // analyze parameters: callSignature.Analyze(analyzer, signature, info, false); // get properties: analyzer.AddCurrentRoutineProperty(routine.GetCallerRequirements()); return new Evaluation(this); } } // by default, fall back to dynamic method invocation routine = null; callSignature.Analyze(analyzer, UnknownSignature.Default, info, false); return new Evaluation(this); }
/// <summary> /// Analyze the function call (isMemberOf == null). /// </summary> /// <param name="analyzer"></param> /// <param name="info"></param> /// <returns></returns> /// <remarks>This code fragment is separated to save the stack when too long Expression chain is being compiled.</remarks> private Evaluation AnalyzeFunctionCall(Analyzer/*!*/ analyzer, ref ExInfoFromParent info) { Debug.Assert(isMemberOf == null); // resolve name: routine = analyzer.ResolveFunctionName(qualifiedName, position); if (routine.IsUnknown) { // note: we've to try following at run time, there can be dynamically added namespaced function matching qualifiedName //// try fallback //if (this.fallbackQualifiedName.HasValue) //{ // routine = analyzer.ResolveFunctionName(this.fallbackQualifiedName.Value, position); //} //if (routine.IsUnknown) // still unknown ? Statistics.AST.AddUnknownFunctionCall(qualifiedName); } // resolve overload if applicable: RoutineSignature signature; overloadIndex = routine.ResolveOverload(analyzer, callSignature, position, out signature); Debug.Assert(overloadIndex != DRoutine.InvalidOverloadIndex, "A function should have at least one overload"); if (routine is PhpLibraryFunction) { var opts = ((PhpLibraryFunction)routine).Options; // warning if not supported function call is detected if ((opts & FunctionImplOptions.NotSupported) != 0) analyzer.ErrorSink.Add(Warnings.NotSupportedFunctionCalled, analyzer.SourceUnit, Position, QualifiedName.ToString()); // warning if function requiring locals is detected (performance critical) if ((opts & FunctionImplOptions.NeedsVariables) != 0 && !analyzer.CurrentScope.IsGlobal) analyzer.ErrorSink.Add(Warnings.UnoptimizedLocalsInFunction, analyzer.SourceUnit, Position, QualifiedName.ToString()); } // analyze parameters: callSignature.Analyze(analyzer, signature, info, false); // get properties: analyzer.AddCurrentRoutineProperty(routine.GetCallerRequirements()); // replaces the node if its value can be determined at compile-time: object value; return TryEvaluate(analyzer, out value) ? new Evaluation(this, value) : new Evaluation(this); }