Exemplo n.º 1
0
 /// <summary>
 /// Visit function call actual parameters.
 /// </summary>
 /// <param name="x"></param>
 virtual public void VisitDirectStMtdCall(DirectStMtdCall x)
 {
     VisitFunctionCall(x);
 }
Exemplo n.º 2
0
 /// <summary>
 /// Visit function call actual parameters.
 /// </summary>
 /// <param name="x"></param>
 virtual public void VisitDirectStMtdCall(DirectStMtdCall x)
 {
     VisitElement(x.TypeRef);
     VisitFunctionCall(x);
 }
Exemplo n.º 3
0
 /// <summary>
 /// Visit function call actual parameters.
 /// </summary>
 /// <param name="x"></param>
 virtual public void VisitDirectStMtdCall(DirectStMtdCall x)
 {
     VisitElement(x.TypeRef);            
     VisitFunctionCall(x);
 }
Exemplo n.º 4
0
 /// <summary>
 /// Visit function call actual parameters.
 /// </summary>
 /// <param name="x"></param>
 virtual public void VisitDirectStMtdCall(DirectStMtdCall x)
 {
     VisitFunctionCall(x);
 }
Exemplo n.º 5
0
		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);
		}