public object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
{
B.Constructor m = new B.Constructor(GetLexicalInfo(constructorDeclaration));
m.Modifiers = ConvertModifier(constructorDeclaration, B.TypeMemberModifiers.Private);
ConvertAttributes(constructorDeclaration.Attributes, m.Attributes);
if (currentType != null)
{
currentType.Members.Add(m);
}
ConvertParameters(constructorDeclaration.Parameters, m.Parameters);
m.EndSourceLocation = GetEndLocation((INode)constructorDeclaration.Body ?? constructorDeclaration);
m.Body = ConvertMethodBlock(constructorDeclaration.Body);
ConstructorInitializer ci = constructorDeclaration.ConstructorInitializer;
if (ci != null && !ci.IsNull)
{
B.Expression initializerBase;
if (ci.ConstructorInitializerType == ConstructorInitializerType.Base)
{
initializerBase = new B.SuperLiteralExpression();
}
else
{
initializerBase = new B.SelfLiteralExpression();
}
B.MethodInvocationExpression initializer = new B.MethodInvocationExpression(initializerBase);
ConvertExpressions(ci.Arguments, initializer.Arguments);
m.Body.Insert(0, new B.ExpressionStatement(initializer));
}
return(m);
}
public static Constructor CreateConstructor(Node lexicalInfoProvider, TypeMemberModifiers modifiers)
{
Constructor constructor = new Constructor(lexicalInfoProvider.LexicalInfo);
constructor.Modifiers = modifiers;
constructor.IsSynthetic = true;
return constructor;
}
public override void LeaveConstructor(Constructor node)
{
if (!node.IsVisibilitySet)
{
node.Modifiers |= TypeMemberModifiers.Public;
}
}
// create a constructor that delegate to the base class
private void AddConstructor(ClassDefinition macro)
{
var ctor = new Constructor(macro.LexicalInfo);
ctor.Parameters.Add(
new ParameterDeclaration("viewEngine",
new SimpleTypeReference("MvcContrib.BrailViewEngine.BooViewEngine"))); // TODO: Update Reference
// ctor.Parameters.Add(
// new ParameterDeclaration("output",
// new SimpleTypeReference("System.IO.TextWriter")));
// ctor.Parameters.Add(
// new ParameterDeclaration("context",
// new SimpleTypeReference("Castle.MonoRail.Framework.IEngineContext")));
//
// ctor.Parameters.Add(
// new ParameterDeclaration("__controller",
// new SimpleTypeReference("Castle.MonoRail.Framework.IController")));
//
// ctor.Parameters.Add(
// new ParameterDeclaration("__controllerContext",
// new SimpleTypeReference("Castle.MonoRail.Framework.IControllerContext")));
var mie = new MethodInvocationExpression(new SuperLiteralExpression());
mie.Arguments.Add(AstUtil.CreateReferenceExpression("viewEngine"));
// mie.Arguments.Add(AstUtil.CreateReferenceExpression("output"));
// mie.Arguments.Add(AstUtil.CreateReferenceExpression("context"));
// mie.Arguments.Add(AstUtil.CreateReferenceExpression("__controller"));
// mie.Arguments.Add(AstUtil.CreateReferenceExpression("__controllerContext"));
ctor.Body.Add(mie);
macro.Members.Add(ctor);
}
public override void LeaveConstructor(Constructor node)
{
if (node.IsVisibilitySet) return;
if (!node.IsStatic)
node.Modifiers |= Context.Parameters.DefaultMethodVisibility;
else
node.Modifiers |= TypeMemberModifiers.Private;
}
public override void LeaveConstructor(Constructor node)
{
MakeStaticIfNeeded(node);
CantBeMarkedTransient(node);
CantBeMarkedPartial(node);
CantBeMarkedFinal(node);
CannotReturnValue(node);
ConstructorCannotBePolymorphic(node);
}
public override void OnConstructor(AST.Constructor node)
{
if (node.IsSynthetic && node.Parameters.Count == 0)
{
return;
}
Constructor ctor = new Constructor(GetModifier(node), GetRegion(node), GetClientRegion(node), OuterClass);
ConvertAttributes(node, ctor);
ConvertParameters(node.Parameters, ctor);
_currentClass.Peek().Methods.Add(ctor);
ctor.UserData = node;
}
private void GenerateConstructors(TypeDefinition definition)
{
ConstructorInfo[] ctors =
baseClass.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
foreach (ConstructorInfo ctor in ctors)
{
if (ctor.IsPrivate)
continue;
Constructor constructor = new Constructor(definition.LexicalInfo);
definition.Members.Add(constructor);
MethodInvocationExpression super = new MethodInvocationExpression(new SuperLiteralExpression());
constructor.Body.Add(super);
foreach (ParameterInfo info in ctor.GetParameters())
{
SimpleTypeReference typeReference =
new SimpleTypeReference(TypeUtilities.GetFullName(info.ParameterType));
constructor.Parameters.Add(new ParameterDeclaration(info.Name,
typeReference)
);
super.Arguments.Add(new ReferenceExpression(info.Name));
}
}
}
public override bool EnterConstructor(Constructor node)
{
base.EnterConstructor(node);
return EnterMethod(node);
}
public override void LeaveConstructor(Constructor node)
{
base.LeaveConstructor(node);
LeaveMethod(node);
}
public override void OnConstructor(Constructor node)
{
Visit(node.Parameters);
_emitter.EmitConstructorAttributes(node);
}
public override void OnConstructor(Constructor constructor)
{
if (constructor.IsRuntime) return;
ConstructorBuilder builder = GetConstructorBuilder(constructor);
EmitMethod(constructor, builder.GetILGenerator());
}
void EmitConstructorAttributes(Constructor node)
{
ConstructorBuilder builder = (ConstructorBuilder)GetBuilder(node);
EmitAttributes(node, builder.SetCustomAttribute);
}
public static CompilerError InstanceMethodInvocationBeforeInitialization(Constructor ctor, MemberReferenceExpression mre)
{
return Instantiate("BCE0158", mre, mre.Name, SelfKeyword);
}
private IMethod EntityFor(Constructor node)
{
return (IMethod)EntityFor((TypeMember)node);
}
//ECMA-335 Partition III Section 1.8.1.4
//cannot call an instance method before super/self.
void CheckInstanceMethodInvocationsWithinConstructor(Constructor ctor)
{
if (ctor.Body.IsEmpty)
return;
foreach (Statement st in ctor.Body.Statements)
{
ExpressionStatement est = st as ExpressionStatement;
if (null == est) continue;
MethodInvocationExpression mie = est.Expression as MethodInvocationExpression;
if (null == mie) continue;
if (mie.Target is SelfLiteralExpression
|| mie.Target is SuperLiteralExpression)
break;//okay we're done checking
if (mie.Target is MemberReferenceExpression)
{
MemberReferenceExpression mre = (MemberReferenceExpression) mie.Target;
if (mre.Target is SelfLiteralExpression
|| mre.Target is SuperLiteralExpression)
{
Error(CompilerErrorFactory.InstanceMethodInvocationBeforeInitialization(ctor, mre));
}
}
}
}
public object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
{
B.Constructor m = new B.Constructor(GetLexicalInfo(constructorDeclaration));
m.Modifiers = ConvertModifier(constructorDeclaration, B.TypeMemberModifiers.Private);
ConvertAttributes(constructorDeclaration.Attributes, m.Attributes);
if (currentType != null) currentType.Members.Add(m);
ConvertParameters(constructorDeclaration.Parameters, m.Parameters);
m.EndSourceLocation = GetEndLocation((INode)constructorDeclaration.Body ?? constructorDeclaration);
m.Body = ConvertMethodBlock(constructorDeclaration.Body);
ConstructorInitializer ci = constructorDeclaration.ConstructorInitializer;
if (ci != null && !ci.IsNull) {
B.Expression initializerBase;
if (ci.ConstructorInitializerType == ConstructorInitializerType.Base)
initializerBase = new B.SuperLiteralExpression();
else
initializerBase = new B.SelfLiteralExpression();
B.MethodInvocationExpression initializer = new B.MethodInvocationExpression(initializerBase);
ConvertExpressions(ci.Arguments, initializer.Arguments);
m.Body.Insert(0, new B.ExpressionStatement(initializer));
}
return m;
}
public override void LeaveConstructor(Constructor node)
{
LeaveMember(node);
}
public override void OnConstructor(Constructor node)
{
CheckExtensionSemantics(node);
}
public override void OnConstructor(Constructor node)
{
if (null == node.Entity)
{
node.Entity = new InternalConstructor(TypeSystemServices, node);
}
_parameters.Add(node);
}
public override void OnConstructor(Constructor node)
{
OnMethod(node);
}
protected void method(
TypeMemberCollection container
) //throws RecognitionException, TokenStreamException
{
IToken t = null;
IToken spliceBegin = null;
IToken c = null;
IToken d = null;
IToken cc = null;
IToken dd = null;
Method m = null;
TypeReference rt = null;
TypeReference it = null;
ExplicitMemberInfo emi = null;
ParameterDeclarationCollection parameters = null;
GenericParameterDeclarationCollection genericParameters = null;
Block body = null;
StatementCollection statements = null;
Expression nameSplice = null;
TypeMember typeMember = null;
IToken id = null;
try { // for error handling
{
switch ( LA(1) )
{
case DEF:
{
t = LT(1);
match(DEF);
{
switch ( LA(1) )
{
case EVENT:
case GET:
case INTERNAL:
case PUBLIC:
case PROTECTED:
case REF:
case SET:
case YIELD:
case ID:
case SPLICE_BEGIN:
{
{
{
{
if ((LA(1)==ID) && (LA(2)==DOT))
{
emi=explicit_member_info();
}
else if ((tokenSet_33_.member(LA(1))) && (tokenSet_34_.member(LA(2)))) {
}
else
{
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1) )
{
case EVENT:
case GET:
case INTERNAL:
case PUBLIC:
case PROTECTED:
case REF:
case SET:
case YIELD:
case ID:
{
id=member();
break;
}
case SPLICE_BEGIN:
{
spliceBegin = LT(1);
match(SPLICE_BEGIN);
nameSplice=atom();
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
if (0==inputState.guessing)
{
IToken token = id ?? spliceBegin;
if (emi != null) {
m = new Method(emi.LexicalInfo);
} else {
m = new Method(ToLexicalInfo(token));
}
m.Name = token.getText();
m.ExplicitInfo = emi;
if (nameSplice != null) {
typeMember = new SpliceTypeMember(m, nameSplice);
} else {
typeMember = m;
}
}
}
break;
}
case CONSTRUCTOR:
{
c = LT(1);
match(CONSTRUCTOR);
if (0==inputState.guessing)
{
typeMember = m = new Constructor(ToLexicalInfo(c));
}
break;
}
case DESTRUCTOR:
{
d = LT(1);
match(DESTRUCTOR);
if (0==inputState.guessing)
{
typeMember = m = new Destructor(ToLexicalInfo(d));
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case CONSTRUCTOR:
{
cc = LT(1);
match(CONSTRUCTOR);
if (0==inputState.guessing)
{
typeMember = m = new Constructor(ToLexicalInfo(cc));
}
break;
}
case DESTRUCTOR:
{
dd = LT(1);
match(DESTRUCTOR);
if (0==inputState.guessing)
{
typeMember = m = new Destructor(ToLexicalInfo(dd));
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if (0==inputState.guessing)
{
m.Modifiers = _modifiers;
AddAttributes(m.Attributes);
parameters = m.Parameters;
genericParameters = m.GenericParameters;
body = m.Body;
statements = body.Statements;
}
{
if ((LA(1)==LBRACK) && (LA(2)==OF||LA(2)==ID))
{
match(LBRACK);
{
switch ( LA(1) )
{
case OF:
{
match(OF);
break;
}
case ID:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
generic_parameter_declaration_list(genericParameters);
match(RBRACK);
}
else if ((tokenSet_35_.member(LA(1))) && (tokenSet_36_.member(LA(2)))) {
}
else
{
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1) )
{
case LPAREN:
{
match(LPAREN);
parameter_declaration_list(parameters);
match(RPAREN);
break;
}
case AS:
case LBRACK:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
attributes();
if (0==inputState.guessing)
{
AddAttributes(m.ReturnTypeAttributes);
}
{
switch ( LA(1) )
{
case AS:
{
match(AS);
rt=type_reference();
if (0==inputState.guessing)
{
m.ReturnType = rt;
}
break;
}
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
begin_block_with_doc(m, body);
block(statements);
end(body);
if (0==inputState.guessing)
{
container.Add(typeMember);
m.EndSourceLocation = body.EndSourceLocation;
}
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex, "method");
recover(ex,tokenSet_22_);
}
else
{
throw ex;
}
}
}
public Constructor CreateConstructor(TypeMemberModifiers modifiers)
{
Constructor constructor = new Constructor();
constructor.Modifiers = modifiers;
constructor.IsSynthetic = true;
EnsureEntityFor(constructor);
return constructor;
}
void ConstructorCannotBePolymorphic(Constructor node)
{
if (node.IsAbstract || node.IsOverride || node.IsVirtual)
{
Error(CompilerErrorFactory.ConstructorCantBePolymorphic(node, EntityFor(node)));
}
}
public BooMethodBuilder AddConstructor()
{
Constructor constructor = new Constructor();
constructor.IsSynthetic = true;
constructor.Modifiers = TypeMemberModifiers.Public;
constructor.Entity = new InternalConstructor(_codeBuilder.TypeSystemServices, constructor);
_cd.Members.Add(constructor);
return new BooMethodBuilder(_codeBuilder, constructor);
}
//throws RecognitionException, TokenStreamException
protected void method(
TypeMemberCollection container
)
{
IToken t = null;
IToken c = null;
IToken d = null;
Method m = null;
TypeReference rt = null;
TypeReference it = null;
ExplicitMemberInfo emi = null;
ParameterDeclarationCollection parameters = null;
GenericParameterDeclarationCollection genericParameters = null;
Block body = null;
StatementCollection statements = null;
IToken id = null;
try { // for error handling
t = LT(1);
match(DEF);
{
switch ( LA(1) )
{
case EVENT:
case GET:
case INTERNAL:
case PUBLIC:
case PROTECTED:
case REF:
case SET:
case ID:
{
{
if ((LA(1)==ID) && (LA(2)==DOT))
{
emi=explicit_member_info();
}
else if ((tokenSet_27_.member(LA(1))) && (LA(2)==LPAREN||LA(2)==LBRACK)) {
}
else
{
throw new NoViableAltException(LT(1), getFilename());
}
}
id=member();
if (0==inputState.guessing)
{
if (emi != null)
{
m = new Method(emi.LexicalInfo);
}
else
{
m = new Method(SourceLocationFactory.ToLexicalInfo(id));
}
m.Name = id.getText();
m.ExplicitInfo = emi;
}
break;
}
case CONSTRUCTOR:
{
c = LT(1);
match(CONSTRUCTOR);
if (0==inputState.guessing)
{
m = new Constructor(SourceLocationFactory.ToLexicalInfo(c));
}
break;
}
case DESTRUCTOR:
{
d = LT(1);
match(DESTRUCTOR);
if (0==inputState.guessing)
{
m = new Destructor(SourceLocationFactory.ToLexicalInfo(d));
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if (0==inputState.guessing)
{
m.Modifiers = _modifiers;
AddAttributes(m.Attributes);
parameters = m.Parameters;
genericParameters = m.GenericParameters;
body = m.Body;
statements = body.Statements;
}
{
switch ( LA(1) )
{
case LBRACK:
{
match(LBRACK);
{
switch ( LA(1) )
{
case OF:
{
match(OF);
break;
}
case ID:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
generic_parameter_declaration_list(genericParameters);
match(RBRACK);
break;
}
case LPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
match(LPAREN);
parameter_declaration_list(parameters);
match(RPAREN);
attributes();
if (0==inputState.guessing)
{
AddAttributes(m.ReturnTypeAttributes);
}
{
switch ( LA(1) )
{
case AS:
{
match(AS);
rt=type_reference();
if (0==inputState.guessing)
{
m.ReturnType = rt;
}
break;
}
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
begin_block_with_doc(m, body);
block(statements);
end(body);
if (0==inputState.guessing)
{
container.Add(m);
}
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex);
recover(ex,tokenSet_32_);
}
else
{
throw ex;
}
}
}
void EmitConstructorAttributes(Constructor node, TypeCreator knownTypes)
{
ConstructorBuilder builder = (ConstructorBuilder)GetBuilder(node);
EmitAttributes(node, builder.SetCustomAttribute, knownTypes);
}
public override void LeaveConstructor(Constructor node)
{
CheckParameterUniqueness(node);
}
public override void OnConstructor(Boo.Lang.Compiler.Ast.Constructor node)
{
ConvertMethod(node, new CodeConstructor());
}
public override void OnConstructor(Constructor node)
{
if (WasVisited(node))
{
return;
}
MarkVisited(node);
Visit(node.Attributes);
Visit(node.Parameters);
InternalConstructor entity = (InternalConstructor)node.Entity;
ProcessMethodBody(entity);
if (node.IsRuntime)
{
CheckRuntimeMethod(node);
}
else
{
if (entity.DeclaringType.IsValueType)
{
if (0 == node.Parameters.Count
&& !node.IsStatic
&& !node.IsSynthetic)
{
Error(CompilerErrorFactory.ValueTypesCannotDeclareParameterlessConstructors(node));
}
}
else if (
!entity.HasSelfCall &&
!entity.HasSuperCall &&
!entity.IsStatic)
{
IType baseType = entity.DeclaringType.BaseType;
IConstructor super = GetCorrectConstructor(node, baseType, EmptyExpressionCollection);
if (null != super)
{
node.Body.Statements.Insert(0,
CodeBuilder.CreateSuperConstructorInvocation(super));
}
}
if (!entity.IsStatic)
CheckInstanceMethodInvocationsWithinConstructor(node);
}
}
public override void OnConstructor(Constructor node)
{
_currentMethod = node;
base.OnConstructor(node);
}
public Constructor CreateStaticConstructor(TypeDefinition type)
{
var constructor = new Constructor();
constructor.IsSynthetic = true;
constructor.Modifiers = TypeMemberModifiers.Private | TypeMemberModifiers.Static;
EnsureEntityFor(constructor);
type.Members.Add(constructor);
return constructor;
}
public override void OnConstructor(Constructor node)
{
_parameters.Add(node);
base.OnConstructor(node);
}