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