override public void LeaveMethod(Method node)
{
InternalMethod derived = (InternalMethod)node.Entity;
IMethod super = derived.Overriden;
if (null != super)
{
TypeMemberModifiers derivedAccess = TypeSystemServices.GetAccess(derived);
TypeMemberModifiers superAccess = TypeSystemServices.GetAccess(super);
if (derivedAccess < superAccess)
{
Error(CompilerErrorFactory.DerivedMethodCannotReduceAccess(
node,
derived,
super,
derivedAccess,
superAccess));
}
}
CheckUnusedLocals(node);
CheckAbstractMethodCantHaveBody(node);
CheckValidExtension(node);
CheckNotFinalizer(node);
CheckImplicitReturn(node);
CheckAmbiguousVariableNames(node);
}
public Field AddField(string name, IType type, TypeMemberModifiers modifiers)
{
Field field = AddField(name, type);
field.Modifiers = modifiers;
return(field);
}
public BooMethodBuilder AddMethod(string name, IType returnType, TypeMemberModifiers modifiers)
{
BooMethodBuilder builder = new BooMethodBuilder(_codeBuilder, name, returnType, modifiers);
_cd.Members.Add(builder.Method);
return(builder);
}
MemberAttributes ConvModifiers(TypeMemberModifiers modifier, MemberAttributes defaultVisibility)
{
MemberAttributes attr = 0;
if ((modifier & TypeMemberModifiers.Abstract) == TypeMemberModifiers.Abstract)
attr |= MemberAttributes.Abstract;
if ((modifier & TypeMemberModifiers.Final) == TypeMemberModifiers.Final)
attr |= MemberAttributes.Const;
if ((modifier & TypeMemberModifiers.Internal) == TypeMemberModifiers.Internal)
attr |= MemberAttributes.Assembly;
if ((modifier & TypeMemberModifiers.Override) == TypeMemberModifiers.Override)
attr |= MemberAttributes.Override;
if ((modifier & TypeMemberModifiers.Private) == TypeMemberModifiers.Private)
attr |= MemberAttributes.Private;
if ((modifier & TypeMemberModifiers.Protected) == TypeMemberModifiers.Protected)
attr |= MemberAttributes.Family;
if ((modifier & TypeMemberModifiers.Public) == TypeMemberModifiers.Public)
attr |= MemberAttributes.Public;
if ((modifier & TypeMemberModifiers.Static) == TypeMemberModifiers.Static)
attr |= MemberAttributes.Static;
if ((modifier & TypeMemberModifiers.Virtual) != TypeMemberModifiers.Virtual)
attr |= MemberAttributes.Final;
if ((modifier & TypeMemberModifiers.VisibilityMask) == TypeMemberModifiers.None)
attr |= defaultVisibility;
return attr;
}
public static Constructor CreateConstructor(Node lexicalInfoProvider, TypeMemberModifiers modifiers)
{
return(new Constructor(lexicalInfoProvider.LexicalInfo)
{
Modifiers = modifiers, IsSynthetic = true
});
}
public BooClassBuilder CreateClass(string name, TypeMemberModifiers modifiers)
{
BooClassBuilder builder = CreateClass(name);
builder.Modifiers = modifiers;
return(builder);
}
public static Constructor CreateConstructor(Node lexicalInfoProvider, TypeMemberModifiers modifiers)
{
Constructor constructor = new Constructor(lexicalInfoProvider.LexicalInfo);
constructor.Modifiers = modifiers;
constructor.IsSynthetic = true;
return constructor;
}
Constructor CreateConstructor(Node lexicalInfoProvider, TypeMemberModifiers modifiers)
{
Constructor constructor = new Constructor(lexicalInfoProvider.LexicalInfo);
constructor.Name = "constructor";
constructor.Modifiers = modifiers;
return(constructor);
}
public static Constructor CreateConstructor(Node lexicalInfoProvider, TypeMemberModifiers modifiers)
{
Constructor constructor = new Constructor(lexicalInfoProvider.LexicalInfo);
constructor.Modifiers = modifiers;
constructor.IsSynthetic = true;
return(constructor);
}
public Constructor CreateConstructor(TypeMemberModifiers modifiers)
{
Constructor constructor = new Constructor();
constructor.Modifiers = modifiers;
constructor.Entity = new InternalConstructor(_tss, constructor);
return(constructor);
}
public Constructor CreateConstructor(TypeMemberModifiers modifiers)
{
Constructor constructor = new Constructor();
constructor.Modifiers = modifiers;
constructor.IsSynthetic = true;
EnsureEntityFor(constructor);
return(constructor);
}
TypeMemberModifiers RemoveAccessiblityModifiers(TypeMemberModifiers modifiers)
{
TypeMemberModifiers mask = TypeMemberModifiers.Public |
TypeMemberModifiers.Protected |
TypeMemberModifiers.Private |
TypeMemberModifiers.Internal;
return(modifiers & ~mask);
}
public Method CreateMethod(string name, TypeReference returnType, TypeMemberModifiers modifiers)
{
Method method = new Method(name);
method.Modifiers = modifiers;
method.ReturnType = returnType;
method.Entity = new InternalMethod(_tss, method);
return(method);
}
public BooMethodBuilder(BooCodeBuilder codeBuilder, string name, IType returnType, TypeMemberModifiers modifiers)
{
if (null == codeBuilder)
throw new ArgumentNullException("codeBuilder");
if (null == name)
throw new ArgumentNullException("name");
_codeBuilder = codeBuilder;
_method = _codeBuilder.CreateMethod(name, returnType, modifiers);
}
public static Constructor CreateDefaultConstructor(TypeDefinition type)
{
TypeMemberModifiers modifiers = TypeMemberModifiers.Public;
if (type.IsAbstract)
{
modifiers = TypeMemberModifiers.Protected;
}
return(CreateConstructor(type, modifiers));
}
public Method CreateMethod(string name, TypeReference returnType, TypeMemberModifiers modifiers)
{
Method method = new Method(name);
method.Modifiers = modifiers;
method.ReturnType = returnType;
method.IsSynthetic = true;
EnsureEntityFor(method);
return(method);
}
public Method CreateGenericMethod(string name, TypeReference returnType, TypeMemberModifiers modifiers, GenericParameterDeclaration[] genParams)
{
Method method = new Method(name);
method.Modifiers = modifiers;
method.ReturnType = returnType;
method.IsSynthetic = true;
method.GenericParameters.AddRange(genParams);
EnsureEntityFor(method);
return(method);
}
protected virtual void OnNonStrictMode()
{
_defaultTypeVisibility = TypeMemberModifiers.Public;
_defaultMethodVisibility = TypeMemberModifiers.Public;
_defaultPropertyVisibility = TypeMemberModifiers.Public;
_defaultEventVisibility = TypeMemberModifiers.Public;
_defaultFieldVisibility = TypeMemberModifiers.Protected;
DisableWarning(CompilerWarningFactory.Codes.ImplicitReturn);
DisableWarning(CompilerWarningFactory.Codes.VisibleMemberDoesNotDeclareTypeExplicitely);
DisableWarning(CompilerWarningFactory.Codes.ImplicitDowncast);
}
void InvalidCombination(TypeMember member, TypeMemberModifiers mod1, TypeMemberModifiers mod2)
{
if (!member.IsModifierSet(mod1) || !member.IsModifierSet(mod2))
{
return;
}
Error(
CompilerErrorFactory.InvalidCombinationOfModifiers(
member,
member.FullName,
string.Format("{0}, {1}", mod1.ToString().ToLower(), mod2.ToString().ToLower())));
}
Method CreateEventRaiseMethod(Event node, Field backingField)
{
TypeMemberModifiers modifiers = RemoveAccessiblityModifiers(node.Modifiers);
if (node.IsPrivate)
{
modifiers |= TypeMemberModifiers.Private;
}
else
{
modifiers |= TypeMemberModifiers.Protected | TypeMemberModifiers.Internal;
}
Method method = CodeBuilder.CreateMethod("raise_" + node.Name,
TypeSystemServices.VoidType,
modifiers);
ICallableType type = GetEntity(node.Type) as ICallableType;
if (null != type)
{
int index = CodeBuilder.GetFirstParameterIndex(node);
foreach (IParameter parameter in type.GetSignature().Parameters)
{
method.Parameters.Add(
CodeBuilder.CreateParameterDeclaration(
index,
parameter.Name,
parameter.Type,
parameter.IsByRef));
++index;
}
}
MethodInvocationExpression mie = CodeBuilder.CreateMethodInvocation(
CodeBuilder.CreateReference(backingField),
NameResolutionService.ResolveMethod(GetType(backingField.Type), "Invoke"));
foreach (ParameterDeclaration parameter in method.Parameters)
{
mie.Arguments.Add(CodeBuilder.CreateReference(parameter));
}
IfStatement stmt = new IfStatement(node.LexicalInfo);
stmt.Condition = CodeBuilder.CreateNotNullTest(
CodeBuilder.CreateReference(backingField));
stmt.TrueBlock = new Block();
stmt.TrueBlock.Add(mie);
method.Body.Add(stmt);
return(method);
}
public Property AddReadOnlyProperty(string name, IType type)
{
TypeMemberModifiers modifiers = TypeMemberModifiers.Public;
Property property = new Property(name);
property.Modifiers = modifiers;
property.Type = _codeBuilder.CreateTypeReference(type);
property.Entity = new InternalProperty(_codeBuilder.TypeSystemServices, property);
property.Getter = _codeBuilder.CreateMethod("get_" + name, type, modifiers);
_cd.Members.Add(property);
return(property);
}
protected virtual void OnStrictMode()
{
_defaultTypeVisibility = TypeMemberModifiers.Private;
_defaultMethodVisibility = TypeMemberModifiers.Private;
_defaultPropertyVisibility = TypeMemberModifiers.Private;
_defaultEventVisibility = TypeMemberModifiers.Private;
_defaultFieldVisibility = TypeMemberModifiers.Private;
EnableWarning(CompilerWarningFactory.Codes.ImplicitReturn);
EnableWarning(CompilerWarningFactory.Codes.VisibleMemberDoesNotDeclareTypeExplicitely);
//by default strict mode forbids implicit downcasts
//disable warning so we get only the regular incompatible type error
DisableWarning(CompilerWarningFactory.Codes.ImplicitDowncast);
}
MemberAttributes ConvModifiers(TypeMemberModifiers modifier, MemberAttributes defaultVisibility)
{
MemberAttributes attr = 0;
if ((modifier & TypeMemberModifiers.Abstract) == TypeMemberModifiers.Abstract)
{
attr |= MemberAttributes.Abstract;
}
if ((modifier & TypeMemberModifiers.Final) == TypeMemberModifiers.Final)
{
attr |= MemberAttributes.Const;
}
if ((modifier & TypeMemberModifiers.Internal) == TypeMemberModifiers.Internal)
{
attr |= MemberAttributes.Assembly;
}
if ((modifier & TypeMemberModifiers.Override) == TypeMemberModifiers.Override)
{
attr |= MemberAttributes.Override;
}
if ((modifier & TypeMemberModifiers.Private) == TypeMemberModifiers.Private)
{
attr |= MemberAttributes.Private;
}
if ((modifier & TypeMemberModifiers.Protected) == TypeMemberModifiers.Protected)
{
attr |= MemberAttributes.Family;
}
if ((modifier & TypeMemberModifiers.Public) == TypeMemberModifiers.Public)
{
attr |= MemberAttributes.Public;
}
if ((modifier & TypeMemberModifiers.Static) == TypeMemberModifiers.Static)
{
attr |= MemberAttributes.Static;
}
if ((modifier & TypeMemberModifiers.Virtual) != TypeMemberModifiers.Virtual)
{
attr |= MemberAttributes.Final;
}
if ((modifier & TypeMemberModifiers.VisibilityMask) == TypeMemberModifiers.None)
{
attr |= defaultVisibility;
}
return(attr);
}
private MemberAttributes ModifiersToDomAttributes(TypeMemberModifiers value)
{
MemberAttributes memberAttributes = default(MemberAttributes);
MemberAttributes memberAttributes2 = memberAttributes;
if ((TypeMemberModifiers.Private & value) != 0)
{
memberAttributes2 |= MemberAttributes.Private;
}
if ((TypeMemberModifiers.Internal & value) != 0)
{
memberAttributes2 |= MemberAttributes.Assembly;
}
if ((TypeMemberModifiers.Protected & value) != 0)
{
memberAttributes2 |= MemberAttributes.Family;
}
if ((TypeMemberModifiers.Public & value) != 0)
{
memberAttributes2 |= MemberAttributes.Public;
}
if ((TypeMemberModifiers.Static & value) != 0)
{
memberAttributes2 |= MemberAttributes.Static;
}
if ((TypeMemberModifiers.Virtual & value) == TypeMemberModifiers.None && (TypeMemberModifiers.Override & value) == TypeMemberModifiers.None)
{
memberAttributes2 |= MemberAttributes.Final;
}
if ((TypeMemberModifiers.Override & value) != 0)
{
memberAttributes2 |= MemberAttributes.Override;
}
if ((TypeMemberModifiers.Abstract & value) != 0)
{
memberAttributes2 |= MemberAttributes.Abstract;
}
if ((TypeMemberModifiers.New & value) != 0)
{
memberAttributes2 |= MemberAttributes.New;
}
return(memberAttributes2);
}
public BooMethodBuilder(BooCodeBuilder codeBuilder,
string name,
IType returnType,
TypeMemberModifiers modifiers)
{
if (null == codeBuilder)
{
throw new ArgumentNullException("codeBuilder");
}
if (null == name)
{
throw new ArgumentNullException("name");
}
_codeBuilder = codeBuilder;
_method = _codeBuilder.CreateMethod(name,
returnType,
modifiers);
}
override public void LeaveMethod(Method node)
{
InternalMethod derived = (InternalMethod)node.Entity;
IMethod super = derived.Overriden;
if (null != super)
{
TypeMemberModifiers derivedAccess = TypeSystemServices.GetAccess(derived);
TypeMemberModifiers superAccess = TypeSystemServices.GetAccess(super);
if (derivedAccess < superAccess)
{
Error(CompilerErrorFactory.DerivedMethodCannotReduceAccess(
node,
derived.FullName,
super.FullName,
derivedAccess,
superAccess));
}
}
CheckUnusedLocals(node);
CheckAbstractMethodCantHaveBody(node);
}
protected void modifiers() //throws RecognitionException, TokenStreamException
{
try { // for error handling
if (0==inputState.guessing)
{
_modifiers = TypeMemberModifiers.None;
}
{ // ( ... )*
for (;;)
{
if ((tokenSet_31_.member(LA(1))))
{
type_member_modifier();
}
else
{
goto _loop202_breakloop;
}
}
_loop202_breakloop: ;
} // ( ... )*
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex, "modifiers");
recover(ex,tokenSet_32_);
}
else
{
throw ex;
}
}
}
public Method CreateMethodFromPrototype(LexicalInfo location, IMethod baseMethod, TypeMemberModifiers newModifiers, string newMethodName)
{
var method = new Method(location);
method.Name = newMethodName;
method.Modifiers = newModifiers;
method.IsSynthetic = true;
if (null != baseMethod.GenericInfo)
DeclareGenericParameters(method, baseMethod.GenericInfo.GenericParameters);
DeclareParameters(method, baseMethod.GetParameters(), baseMethod.IsStatic ? 0 : 1);
method.ReturnType = CreateTypeReference(baseMethod.ReturnType);
EnsureEntityFor(method);
return method;
}
public static CompilerError DerivedMethodCannotReduceAccess(Node node, string derivedMethod, string superMethod, TypeMemberModifiers derivedAccess, TypeMemberModifiers superAccess)
{
return new CompilerError("BCE0090", SafeLexicalInfo(node), derivedMethod, superMethod, superAccess.ToString().ToLower(), derivedAccess.ToString().ToLower());
}
protected virtual void OnNonStrictMode()
{
_defaultTypeVisibility = TypeMemberModifiers.Public;
_defaultMethodVisibility = TypeMemberModifiers.Public;
_defaultPropertyVisibility = TypeMemberModifiers.Public;
_defaultEventVisibility = TypeMemberModifiers.Public;
_defaultFieldVisibility = TypeMemberModifiers.Protected;
DisableWarning(CompilerWarningFactory.Codes.ImplicitReturn);
DisableWarning(CompilerWarningFactory.Codes.VisibleMemberDoesNotDeclareTypeExplicitely);
DisableWarning(CompilerWarningFactory.Codes.ImplicitDowncast);
}
public bool ShouldSerialize(TypeMemberModifiers value)
{
return (long)value != 0;
}
void InvalidCombination(TypeMember member, TypeMemberModifiers mod1, TypeMemberModifiers mod2)
{
if (!member.IsModifierSet(mod1) || !member.IsModifierSet(mod2)) return;
Error(
CompilerErrorFactory.InvalidCombinationOfModifiers(
member,
EntityFor(member),
string.Format("{0}, {1}", mod1.ToString().ToLower(), mod2.ToString().ToLower())));
}
protected TypeMember(TypeMemberModifiers modifiers, string name)
{
this.Modifiers = modifiers;
this.Name = name;
}
public Method CreateMethod(string name, TypeReference returnType, TypeMemberModifiers modifiers)
{
Method method = new Method(name);
method.Modifiers = modifiers;
method.ReturnType = returnType;
method.IsSynthetic = true;
EnsureEntityFor(method);
return method;
}
public Method CreateMethodFromPrototype(LexicalInfo lexicalInfo, IMethod baseMethod, TypeMemberModifiers newModifiers)
{
return CreateMethodFromPrototype(lexicalInfo, baseMethod, newModifiers, baseMethod.Name);
}
public Method CreateMethodFromPrototype(LexicalInfo lexicalInfo, IMethod baseMethod, TypeMemberModifiers newModifiers)
{
Method method = new Method(lexicalInfo);
method.Name = baseMethod.Name;
method.Modifiers = newModifiers;
method.IsSynthetic = true;
IParameter[] parameters = baseMethod.GetParameters();
for (int i = 0; i < parameters.Length; ++i)
{
method.Parameters.Add(CreateParameterDeclaration(i + 1,
"arg" + i,
parameters[i].Type,
parameters[i].IsByRef));
}
method.ReturnType = CreateTypeReference(baseMethod.ReturnType);
method.Entity = new InternalMethod(_tss, method);
return(method);
}
public Constructor CreateConstructor(TypeMemberModifiers modifiers)
{
Constructor constructor = new Constructor();
constructor.Modifiers = modifiers;
constructor.IsSynthetic = true;
EnsureEntityFor(constructor);
return constructor;
}
public bool ShouldSerialize(TypeMemberModifiers value)
{
return value != TypeMemberModifiers.None;
}
public Method CreateMethodFromPrototype(LexicalInfo location, IMethod baseMethod, TypeMemberModifiers newModifiers, string newMethodName)
{
var method = new Method(location);
method.Name = newMethodName;
method.Modifiers = newModifiers;
method.IsSynthetic = true;
var optionalTypeMappings = DeclareGenericParametersFromPrototype(method, baseMethod);
var typeReferenceFactory = optionalTypeMappings != null
? new MappedTypeReferenceFactory(TypeReferenceFactory, optionalTypeMappings)
: TypeReferenceFactory;
_typeReferenceFactory.With(typeReferenceFactory, () =>
{
DeclareParameters(method, baseMethod.GetParameters(), baseMethod.IsStatic ? 0 : 1);
method.ReturnType = CreateTypeReference(baseMethod.ReturnType);
});
EnsureEntityFor(method);
return(method);
}
public BooMethodBuilder AddMethod(string name, IType returnType, TypeMemberModifiers modifiers)
{
BooMethodBuilder builder = new BooMethodBuilder(_codeBuilder, name, returnType, modifiers);
_cd.Members.Add(builder.Method);
return builder;
}
protected void ResetMemberData()
{
_modifiers = TypeMemberModifiers.None;
}
public Field AddField(string name, IType type, TypeMemberModifiers modifiers)
{
Field field = AddField(name, type);
field.Modifiers = modifiers;
return field;
}
protected void type_member_modifier() //throws RecognitionException, TokenStreamException
{
IToken t = null;
try { // for error handling
switch ( LA(1) )
{
case STATIC:
{
match(STATIC);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Static;
}
break;
}
case PUBLIC:
{
match(PUBLIC);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Public;
}
break;
}
case PROTECTED:
{
match(PROTECTED);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Protected;
}
break;
}
case PRIVATE:
{
match(PRIVATE);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Private;
}
break;
}
case INTERNAL:
{
match(INTERNAL);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Internal;
}
break;
}
case FINAL:
{
match(FINAL);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Final;
}
break;
}
case TRANSIENT:
{
t = LT(1);
match(TRANSIENT);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Transient;
EmitTransientKeywordDeprecationWarning(ToLexicalInfo(t));
}
break;
}
case OVERRIDE:
{
match(OVERRIDE);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Override;
}
break;
}
case ABSTRACT:
{
match(ABSTRACT);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Abstract;
}
break;
}
case VIRTUAL:
{
match(VIRTUAL);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Virtual;
}
break;
}
case NEW:
{
match(NEW);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.New;
}
break;
}
case PARTIAL:
{
match(PARTIAL);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Partial;
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex, "type_member_modifier");
recover(ex,tokenSet_85_);
}
else
{
throw ex;
}
}
}
public static CompilerError DerivedMethodCannotReduceAccess(Node node, IMethod derivedMethod, IMethod superMethod, TypeMemberModifiers derivedAccess, TypeMemberModifiers superAccess)
{
return(Instantiate("BCE0090", node, derivedMethod, superMethod, superAccess.ToString().ToLower(), derivedAccess.ToString().ToLower()));
}
public bool IsModifierSet(TypeMemberModifiers modifiers)
{
return modifiers == (_modifiers & modifiers);
}
//throws RecognitionException, TokenStreamException
protected void modifiers()
{
_modifiers = TypeMemberModifiers.None;
try { // for error handling
{ // ( ... )*
for (;;)
{
switch ( LA(1) )
{
case STATIC:
{
match(STATIC);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Static;
}
break;
}
case PUBLIC:
{
match(PUBLIC);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Public;
}
break;
}
case PROTECTED:
{
match(PROTECTED);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Protected;
}
break;
}
case PRIVATE:
{
match(PRIVATE);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Private;
}
break;
}
case INTERNAL:
{
match(INTERNAL);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Internal;
}
break;
}
case FINAL:
{
match(FINAL);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Final;
}
break;
}
case TRANSIENT:
{
match(TRANSIENT);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Transient;
}
break;
}
case OVERRIDE:
{
match(OVERRIDE);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Override;
}
break;
}
case ABSTRACT:
{
match(ABSTRACT);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Abstract;
}
break;
}
case VIRTUAL:
{
match(VIRTUAL);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Virtual;
}
break;
}
case PARTIAL:
{
match(PARTIAL);
if (0==inputState.guessing)
{
_modifiers |= TypeMemberModifiers.Partial;
}
break;
}
default:
{
goto _loop166_breakloop;
}
}
}
_loop166_breakloop: ;
} // ( ... )*
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex);
recover(ex,tokenSet_20_);
}
else
{
throw ex;
}
}
}
Method CreateInitializerMethod(TypeDefinition type, string name, TypeMemberModifiers modifiers)
{
Method method = CodeBuilder.CreateMethod(name, TypeSystemServices.VoidType, modifiers);
type.Members.Add(method);
MarkVisited(method);
return method;
}
public static CompilerError DerivedMethodCannotReduceAccess(Node node, string derivedMethod, string superMethod, TypeMemberModifiers derivedAccess, TypeMemberModifiers superAccess)
{
return(new CompilerError("BCE0090", SafeLexicalInfo(node), derivedMethod, superMethod, superAccess.ToString().ToLower(), derivedAccess.ToString().ToLower()));
}
protected virtual void OnStrictMode()
{
_defaultTypeVisibility = TypeMemberModifiers.Private;
_defaultMethodVisibility = TypeMemberModifiers.Private;
_defaultPropertyVisibility = TypeMemberModifiers.Private;
_defaultEventVisibility = TypeMemberModifiers.Private;
_defaultFieldVisibility = TypeMemberModifiers.Private;
EnableWarning(CompilerWarningFactory.Codes.ImplicitReturn);
EnableWarning(CompilerWarningFactory.Codes.VisibleMemberDoesNotDeclareTypeExplicitely);
//by default strict mode forbids implicit downcasts
//disable warning so we get only the regular incompatible type error
DisableWarning(CompilerWarningFactory.Codes.ImplicitDowncast);
}
public Expression Serialize(TypeMemberModifiers value)
{
return SerializeEnum("TypeMemberModifiers", (long)value);
}
public Method CreateMethod(string name, IType returnType, TypeMemberModifiers modifiers)
{
return(CreateMethod(name, CreateTypeReference(returnType), modifiers));
}
public static CompilerError DerivedMethodCannotReduceAccess(Node node, string derivedMethod, string superMethod, TypeMemberModifiers derivedAccess, TypeMemberModifiers superAccess)
{
return Instantiate("BCE0090", node, derivedMethod, superMethod, superAccess.ToString().ToLower(), derivedAccess.ToString().ToLower());
}
public BooClassBuilder CreateClass(string name, TypeMemberModifiers modifiers)
{
var builder = CreateClass(name);
builder.Modifiers = modifiers;
return builder;
}
public bool IsModifierSet(TypeMemberModifiers modifiers)
{
return(modifiers == (_modifiers & modifiers));
}
public Method CreateMethod(string name, IType returnType, TypeMemberModifiers modifiers)
{
return CreateMethod(name, CreateTypeReference(returnType), modifiers);
}
protected TypeMember(TypeMemberModifiers modifiers, string name) : base(modifiers, name)
{
}
public Method CreateMethodFromPrototype(IMethod baseMethod, TypeMemberModifiers newModifiers)
{
return CreateMethodFromPrototype(LexicalInfo.Empty, baseMethod, newModifiers);
}
TypeMemberModifiers RemoveAccessiblityModifiers(TypeMemberModifiers modifiers)
{
TypeMemberModifiers mask = TypeMemberModifiers.Public |
TypeMemberModifiers.Protected |
TypeMemberModifiers.Private |
TypeMemberModifiers.Internal;
return modifiers & ~mask ;
}
public Method CreateMethodFromPrototype(LexicalInfo location, IMethod baseMethod, TypeMemberModifiers newModifiers, string newMethodName)
{
var method = new Method(location);
method.Name = newMethodName;
method.Modifiers = newModifiers;
method.IsSynthetic = true;
var optionalTypeMappings = DeclareGenericParametersFromPrototype(method, baseMethod);
var typeReferenceFactory = optionalTypeMappings != null
? new MappedTypeReferenceFactory(TypeReferenceFactory, optionalTypeMappings)
: TypeReferenceFactory;
_typeReferenceFactory.With(typeReferenceFactory, ()=>
{
DeclareParameters(method, baseMethod.GetParameters(), baseMethod.IsStatic ? 0 : 1);
method.ReturnType = CreateTypeReference(baseMethod.ReturnType);
});
EnsureEntityFor(method);
return method;
}
Method CreateInitializerMethod(TypeDefinition type, string name, TypeMemberModifiers modifiers)
{
Method method = new Method(name);
method.Modifiers |= modifiers;
method.ReturnType = CodeBuilder.CreateTypeReference(TypeSystemServices.VoidType);
InternalMethod entity = new InternalMethod(TypeSystemServices, method);
method.Entity = entity;
type.Members.Add(method);
MarkVisited(method);
return method;
}
