/// <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); }
/// <include file='Doc/Nodes.xml' path='doc/method[@name="Expression.Analyze"]/*'/> internal override Evaluation Analyze(Analyzer/*!*/ analyzer, ExInfoFromParent info) { base.Analyze(analyzer, info); // look for the method: bool isCallMethod; method = analyzer.ResolveMethod( type, methodName, position, analyzer.CurrentType, analyzer.CurrentRoutine, true, out runtimeVisibilityCheck, out isCallMethod); if (!method.IsUnknown) { // we are sure about the method // if (method.IsAbstract) { analyzer.ErrorSink.Add(Errors.AbstractMethodCalled, analyzer.SourceUnit, position, method.DeclaringType.FullName, method.FullName); } } // check __callStatic if (isCallMethod) { // TODO: generic args // create new CallSignature({function name},{args}) var arg1 = new StringLiteral(this.Position, methodName.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>()); } // analyze the method RoutineSignature signature; overloadIndex = method.ResolveOverload(analyzer, callSignature, position, out signature); Debug.Assert(overloadIndex != DRoutine.InvalidOverloadIndex, "Each method should have at least one overload"); // analyze arguments callSignature.Analyze(analyzer, signature, info, false); return new Evaluation(this); }
internal override Evaluation Analyze(Analyzer/*!*/ analyzer, ExInfoFromParent info) { Debug.Assert(this.IsMemberOf == null); access = info.Access; this.typeArgsResolved = classNameRef.Analyze(analyzer); DType type = classNameRef.ResolvedType; RoutineSignature signature; if (typeArgsResolved) analyzer.AnalyzeConstructedType(type); if (type != null) { bool error_reported = false; // make checks if we are sure about character of the type: if (type.IsIdentityDefinite) { if (type.IsAbstract || type.IsInterface) { analyzer.ErrorSink.Add(Errors.AbstractClassOrInterfaceInstantiated, analyzer.SourceUnit, position, type.FullName); error_reported = true; } } // disallow instantiation of Closure if (type.RealType == typeof(PHP.Library.SPL.Closure)) { analyzer.ErrorSink.Add(Errors.ClosureInstantiated, analyzer.SourceUnit, position, type.FullName); error_reported = true; } // type name resolved, look the constructor up: constructor = analyzer.ResolveConstructor(type, position, analyzer.CurrentType, analyzer.CurrentRoutine, out runtimeVisibilityCheck); if (constructor.ResolveOverload(analyzer, callSignature, position, out signature) == DRoutine.InvalidOverloadIndex) { if (!error_reported) { analyzer.ErrorSink.Add(Errors.ClassHasNoVisibleCtor, analyzer.SourceUnit, position, type.FullName); } } } else { signature = UnknownSignature.Default; } callSignature.Analyze(analyzer, signature, info, false); return new Evaluation(this); }
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 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); }