/// <summary>
/// Visit function call actual parameters.
/// </summary>
/// <param name="x"></param>
virtual public void VisitDirectStMtdCall(DirectStMtdCall x)
{
VisitFunctionCall(x);
}
/// <summary>
/// Visit function call actual parameters.
/// </summary>
/// <param name="x"></param>
virtual public void VisitDirectStMtdCall(DirectStMtdCall x)
{
VisitElement(x.TypeRef);
VisitFunctionCall(x);
}
/// <summary>
/// Visit function call actual parameters.
/// </summary>
/// <param name="x"></param>
virtual public void VisitDirectStMtdCall(DirectStMtdCall x)
{
VisitElement(x.TypeRef);
VisitFunctionCall(x);
}
/// <summary>
/// Visit function call actual parameters.
/// </summary>
/// <param name="x"></param>
virtual public void VisitDirectStMtdCall(DirectStMtdCall x)
{
VisitFunctionCall(x);
}
internal override void Analyze(Analyzer/*!*/ analyzer)
{
// method redeclared:
if (method == null) return;
base.Analyze(analyzer);
PhpType declaring_type = analyzer.CurrentType;
analyzer.EnterMethodDeclaration(method);
typeSignature.Analyze(analyzer);
signature.Analyze(analyzer);
method.Validate(analyzer.ErrorSink);
// note, if the declaring type's base is unknown then it cannot be a CLR type;
ClrType base_clr_type = method.DeclaringType.Base as ClrType;
if (baseCtorParams != null)
{
if (base_clr_type != null)
{
AnalyzeBaseCtorCallParams(analyzer, base_clr_type);
}
else if (!method.IsConstructor || method.DeclaringType.Base == null || body == null)
{
analyzer.ErrorSink.Add(Errors.UnexpectedParentCtorInvocation, analyzer.SourceUnit, position);
baseCtorParams = null;
}
else if (method.DeclaringType.Base.Constructor == null)
{
// base class has no constructor, the default parameterless is silently called (and that does nothing);
// report error, if there are any parameters passed to the parameterless ctor:
if (baseCtorParams.Count > 0)
analyzer.ErrorSink.Add(Errors.UnexpectedParentCtorInvocation, analyzer.SourceUnit, position);
baseCtorParams = null;
}
else
{
GenericQualifiedName parent_name = new GenericQualifiedName(new QualifiedName(Name.ParentClassName));
DirectStMtdCall call_expr = new DirectStMtdCall(
position, parent_name, Position.Invalid,
method.DeclaringType.Base.Constructor.Name, Position.Invalid,
baseCtorParams, TypeRef.EmptyList);
body.Insert(0, new ExpressionStmt(position, call_expr));
baseCtorParams = null;
}
}
else
{
// the type immediately extends CLR type with no default ctor, yet there is no call to the base ctor;
// note, all constructor overloads reflected from the CLR type are visible as we are in a subclass:
if (method.IsConstructor && base_clr_type != null && !base_clr_type.ClrConstructor.HasParameterlessOverload)
{
analyzer.ErrorSink.Add(Errors.ExpectingParentCtorInvocation, analyzer.SourceUnit, position);
}
}
if(method.IsDllImport && !method.IsStatic)
analyzer.ErrorSink.Add(Errors.DllImportMethodMustBeStatic, analyzer.SourceUnit, position);
if(method.IsDllImport && method.IsAbstract)
analyzer.ErrorSink.Add(Errors.DllImportMethodCannotBeAbstract, analyzer.SourceUnit, position);
if (body != null)
body.Analyze(analyzer);
method.ValidateBody(analyzer.ErrorSink);
analyzer.LeaveMethodDeclaration();
// add entry point if applicable:
analyzer.SetEntryPoint(method, position);
}