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