public override IUnresolvedEntity VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) { Modifiers modifiers = constructorDeclaration.Modifiers; bool isStatic = (modifiers & Modifiers.Static) != 0; DefaultUnresolvedMethod ctor = new DefaultUnresolvedMethod(currentTypeDefinition, isStatic ? ".cctor" : ".ctor"); ctor.EntityType = EntityType.Constructor; ctor.Region = MakeRegion(constructorDeclaration); if (!constructorDeclaration.Initializer.IsNull) { ctor.BodyRegion = MakeRegion(constructorDeclaration.Initializer.StartLocation, constructorDeclaration.EndLocation); } else { ctor.BodyRegion = MakeRegion(constructorDeclaration.Body); } ctor.ReturnType = KnownTypeReference.Void; ConvertAttributes(ctor.Attributes, constructorDeclaration.Attributes); ConvertParameters(ctor.Parameters, constructorDeclaration.Parameters); if (isStatic) ctor.IsStatic = true; else ApplyModifiers(ctor, modifiers); currentTypeDefinition.Members.Add(ctor); if (interningProvider != null) { ctor.ApplyInterningProvider(interningProvider); } return ctor; }
public override IUnresolvedEntity VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) { DefaultUnresolvedMethod m = new DefaultUnresolvedMethod(currentTypeDefinition, methodDeclaration.Name); currentMethod = m; // required for resolving type parameters m.Region = MakeRegion(methodDeclaration); m.BodyRegion = MakeRegion(methodDeclaration.Body); if (InheritsConstraints(methodDeclaration) && methodDeclaration.Constraints.Count == 0) { int index = 0; foreach (TypeParameterDeclaration tpDecl in methodDeclaration.TypeParameters) { var tp = new MethodTypeParameterWithInheritedConstraints(index++, tpDecl.Name); tp.Region = MakeRegion(tpDecl); ConvertAttributes(tp.Attributes, tpDecl.Attributes); tp.Variance = tpDecl.Variance; m.TypeParameters.Add(tp); } } else { ConvertTypeParameters(m.TypeParameters, methodDeclaration.TypeParameters, methodDeclaration.Constraints, EntityType.Method); } m.ReturnType = methodDeclaration.ReturnType.ToTypeReference(); ConvertAttributes(m.Attributes, methodDeclaration.Attributes.Where(s => s.AttributeTarget != "return")); ConvertAttributes(m.ReturnTypeAttributes, methodDeclaration.Attributes.Where(s => s.AttributeTarget == "return")); ApplyModifiers(m, methodDeclaration.Modifiers); if (methodDeclaration.IsExtensionMethod) { m.IsExtensionMethod = true; currentTypeDefinition.HasExtensionMethods = true; } ConvertParameters(m.Parameters, methodDeclaration.Parameters); if (!methodDeclaration.PrivateImplementationType.IsNull) { m.Accessibility = Accessibility.None; m.IsExplicitInterfaceImplementation = true; m.ExplicitInterfaceImplementations.Add(new DefaultMemberReference( m.EntityType, methodDeclaration.PrivateImplementationType.ToTypeReference(), m.Name, m.TypeParameters.Count, GetParameterTypes(m.Parameters))); } currentTypeDefinition.Members.Add(m); currentMethod = null; if (interningProvider != null) { m.ApplyInterningProvider(interningProvider); } return m; }
public override IUnresolvedEntity VisitDestructorDeclaration(DestructorDeclaration destructorDeclaration, object data) { DefaultUnresolvedMethod dtor = new DefaultUnresolvedMethod(currentTypeDefinition, "Finalize"); dtor.EntityType = EntityType.Destructor; dtor.Region = MakeRegion(destructorDeclaration); dtor.BodyRegion = MakeRegion(destructorDeclaration.Body); dtor.Accessibility = Accessibility.Protected; dtor.IsOverride = true; dtor.ReturnType = KnownTypeReference.Void; ConvertAttributes(dtor.Attributes, destructorDeclaration.Attributes); currentTypeDefinition.Members.Add(dtor); if (interningProvider != null) { dtor.ApplyInterningProvider(interningProvider); } return dtor; }
public override IUnresolvedEntity VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data) { DefaultUnresolvedMethod m = new DefaultUnresolvedMethod(currentTypeDefinition, operatorDeclaration.Name); m.EntityType = EntityType.Operator; m.Region = MakeRegion(operatorDeclaration); m.BodyRegion = MakeRegion(operatorDeclaration.Body); m.ReturnType = operatorDeclaration.ReturnType.ToTypeReference(); ConvertAttributes(m.Attributes, operatorDeclaration.Attributes.Where(s => s.AttributeTarget != "return")); ConvertAttributes(m.ReturnTypeAttributes, operatorDeclaration.Attributes.Where(s => s.AttributeTarget == "return")); ApplyModifiers(m, operatorDeclaration.Modifiers); ConvertParameters(m.Parameters, operatorDeclaration.Parameters); currentTypeDefinition.Members.Add(m); if (interningProvider != null) { m.ApplyInterningProvider(interningProvider); } return m; }