public override PhpTypeCode Emit(InstanceOfEx node, CodeGenerator codeGenerator) { Statistics.AST.AddNode("InstanceOfEx"); // emits load of expression value on the stack: codeGenerator.EmitBoxing(node.Expression.Emit(codeGenerator)); var resolvedType = TypeRefHelper.ResolvedType(node.ClassNameRef); if (resolvedType != null && typeArgsResolved) { // type is resolvable (doesn't mean known) // resolvedType.EmitInstanceOf(codeGenerator, null); } else { // type is unresolvable (there is some variable or the type is a generic parameter) // codeGenerator.EmitInstanceOfOperator(null, node.ClassNameRef, null); } if (access == AccessType.None) { codeGenerator.IL.Emit(OpCodes.Pop); return(PhpTypeCode.Void); } else { return(PhpTypeCode.Boolean); } }
public override PhpTypeCode Emit(TypeOfEx node, CodeGenerator codeGenerator) { Statistics.AST.AddNode("TypeOfEx"); var resolvedtype = TypeRefHelper.ResolvedType(node.ClassNameRef); if (resolvedtype != null && typeArgsResolved) { // type is resolvable (doesn't mean known) // resolvedtype.EmitTypeOf(codeGenerator, null); } else { // type is unresolvable (there is some variable or the type is a generic parameter) // codeGenerator.EmitTypeOfOperator(null, node.ClassNameRef, null); } if (access == AccessType.None) { codeGenerator.IL.Emit(OpCodes.Pop); return(PhpTypeCode.Void); } else { return(PhpTypeCode.DObject); } }
internal override bool Analyze(DirectTypeRef node, Analyzer analyzer) { resolvedType = analyzer.ResolveTypeName(node.ClassName, analyzer.CurrentType, analyzer.CurrentRoutine, node.Span, false); // base call must follow the class name resolution: bool args_static = base.Analyze(node, analyzer); if (args_static) { DTypeDesc[] resolved_arguments = DTypeDesc.EmptyArray; var genericParams = node.GenericParams; if (genericParams != null && genericParams.Count > 0) { resolved_arguments = new DTypeDesc[genericParams.Count]; for (int i = 0; i < genericParams.Count; i++) { resolved_arguments[i] = TypeRefHelper.ResolvedType(genericParams[i]).TypeDesc; } } resolvedType = resolvedType.MakeConstructedType(analyzer, resolved_arguments, node.Span); } return(args_static); }
public override Evaluation Analyze(NewEx node, Analyzer analyzer, ExInfoFromParent info) { Debug.Assert(node.IsMemberOf == null); access = info.Access; this.typeArgsResolved = TypeRefHelper.Analyze(node.ClassNameRef, analyzer); DType type = TypeRefHelper.ResolvedType(node.ClassNameRef); 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, node.Span, type.FullName); error_reported = true; } } // disallow instantiation of Closure if (type.RealType == typeof(PHP.Library.SPL.Closure)) { analyzer.ErrorSink.Add(Errors.ClosureInstantiated, analyzer.SourceUnit, node.Span, type.FullName); error_reported = true; } // type name resolved, look the constructor up: constructor = analyzer.ResolveConstructor(type, node.Span, analyzer.CurrentType, analyzer.CurrentRoutine, out runtimeVisibilityCheck); if (constructor.ResolveOverload(analyzer, node.CallSignature, node.Span, out signature) == DRoutine.InvalidOverloadIndex) { if (!error_reported) { analyzer.ErrorSink.Add(Errors.ClassHasNoVisibleCtor, analyzer.SourceUnit, node.Span, type.FullName); } } } else { signature = UnknownSignature.Default; } CallSignatureHelpers.Analyze(node.CallSignature, analyzer, signature, info, false); return(new Evaluation(node)); }
public override Evaluation Analyze(T node, Analyzer analyzer, ExInfoFromParent info) { access = info.Access; TypeRefHelper.Analyze(node.TypeRef, analyzer); this.type = TypeRefHelper.ResolvedTypeOrUnknown(node.TypeRef); analyzer.AnalyzeConstructedType(type); return(new Evaluation(node)); }
/// <summary> /// Resolves generic arguments. /// </summary> /// <returns><B>true</B> iff all arguments are resolvable to types or constructed types (none is variable).</returns> internal virtual bool Analyze(T /*!*/ node, Analyzer /*!*/ analyzer) { bool result = true; foreach (TypeRef arg in node.GenericParams) { result &= TypeRefHelper.Analyze(arg, analyzer); } return(result); }
public override Evaluation Analyze(TypeOfEx node, Analyzer analyzer, ExInfoFromParent info) { access = info.Access; typeArgsResolved = TypeRefHelper.Analyze(node.ClassNameRef, analyzer); if (typeArgsResolved) { analyzer.AnalyzeConstructedType(TypeRefHelper.ResolvedType(node.ClassNameRef)); } return(new Evaluation(node)); }
internal override void ResolveName(T node, Analyzer analyzer) { var typeRef = node.TypeRef; TypeRefHelper.Analyze(typeRef, analyzer); this.type = TypeRefHelper.ResolvedTypeOrUnknown(typeRef); // analyze constructed type (we are in the full analysis): analyzer.AnalyzeConstructedType(type); constant = analyzer.ResolveClassConstantName(type, node.Name, node.Span, analyzer.CurrentType, analyzer.CurrentRoutine, out runtimeVisibilityCheck); }
public override Evaluation Analyze(InstanceOfEx node, Analyzer analyzer, ExInfoFromParent info) { access = info.Access; node.Expression = node.Expression.Analyze(analyzer, ExInfoFromParent.DefaultExInfo).Literalize(); typeArgsResolved = TypeRefHelper.Analyze(node.ClassNameRef, analyzer); if (typeArgsResolved) { analyzer.AnalyzeConstructedType(TypeRefHelper.ResolvedType(node.ClassNameRef)); } return(new Evaluation(node)); }
public void Analyze(CatchItem /*!*/ node, Analyzer /*!*/ analyzer) { ExInfoFromParent info = new ExInfoFromParent(node); info.Access = AccessType.Write; TypeRefHelper.Analyze(node.TypeRef, analyzer); resolvedType = TypeRefHelper.ResolvedTypeOrUnknown(node.TypeRef); //resolvedType = analyzer.ResolveTypeName(node.ClassName, analyzer.CurrentType, analyzer.CurrentRoutine, node.Span, false); node.Variable.Analyze(analyzer, info); analyzer.EnterConditionalCode(); node.Statements.Analyze(analyzer); analyzer.LeaveConditionalCode(); }
/// <summary> /// Emits code that loads type descriptors for all generic arguments and a call to /// <see cref="Operators.MakeGenericTypeInstantiation"/>. /// </summary> internal void EmitMakeGenericInstantiation(TypeRef node, CodeGenerator /*!*/ codeGenerator, ResolveTypeFlags flags) { if (node.GenericParams == null || node.GenericParams.Count == 0) { return; } ILEmitter il = codeGenerator.IL; il.EmitOverloadedArgs(Types.DTypeDesc[0], node.GenericParams.Count, Methods.Operators.MakeGenericTypeInstantiation.ExplicitOverloads, delegate(ILEmitter eil, int i) { TypeRefHelper.EmitLoadTypeDesc(node.GenericParams[i], codeGenerator, flags); }); if (node.GenericParams.Count > 0) { il.Emit(OpCodes.Call, Methods.Operators.MakeGenericTypeInstantiation.Overload(node.GenericParams.Count)); } }
public void Analyze(CallSignature /*!*/ node, Analyzer /*!*/ analyzer, RoutineSignature /*!*/ signature, ExInfoFromParent info, bool isBaseCtorCallConstrained) { // generic: foreach (var p in node.GenericParams) { TypeRefHelper.Analyze(p, analyzer); } // regular: analyzer.EnterActualParams(signature, node.Parameters.Length); foreach (var p in node.Parameters) { p.NodeCompiler <ActualParamCompiler>().Analyze(p, analyzer, isBaseCtorCallConstrained); } analyzer.LeaveActualParams(); }
public override PhpTypeCode Emit(NewEx node, CodeGenerator codeGenerator) { Statistics.AST.AddNode("NewEx"); PhpTypeCode result; var newextype = TypeRefHelper.ResolvedType(node.ClassNameRef); if (newextype != null && typeArgsResolved) { // constructor is resolvable (doesn't mean that known) // result = newextype.EmitNew(codeGenerator, null, constructor, node.CallSignature, runtimeVisibilityCheck); } else { // constructor is unresolvable (a variable is used in type name => type is unresolvable as well) // codeGenerator.EmitNewOperator(null, node.ClassNameRef, null, node.CallSignature); result = PhpTypeCode.Object; } codeGenerator.EmitReturnValueHandling(node, false, ref result); return(result); }
public override bool IsCustomAttributeArgumentValue(TypeOfEx node) { var resolvedtype = TypeRefHelper.ResolvedType(node.ClassNameRef); return(resolvedtype != null && typeArgsResolved && resolvedtype.IsDefinite); }