public virtual void PrintTypeMemberVisibility(TypeMemberVisibility visibility)
{
switch (visibility) {
case TypeMemberVisibility.Public:
PrintKeywordPublic();
break;
case TypeMemberVisibility.Private:
PrintKeywordPrivate();
break;
case TypeMemberVisibility.Assembly:
PrintKeywordInternal();
break;
case TypeMemberVisibility.Family:
PrintKeywordProtected();
break;
case TypeMemberVisibility.FamilyOrAssembly:
PrintKeywordProtectedInternal();
break;
case TypeMemberVisibility.FamilyAndAssembly:
default:
sourceEmitterOutput.Write("Invalid-visibility ");
break;
}
}
public virtual void EmitVisibility(TypeMemberVisibility visibility)
{
switch (visibility)
{
case TypeMemberVisibility.Public:
EmitKeyword("public");
break;
case TypeMemberVisibility.Private:
EmitKeyword("private");
break;
case TypeMemberVisibility.Assembly:
EmitKeyword("internal");
break;
case TypeMemberVisibility.Family:
EmitKeyword("protected");
break;
case TypeMemberVisibility.FamilyOrAssembly:
EmitKeyword("protected internal");
break;
case TypeMemberVisibility.FamilyAndAssembly:
EmitKeyword("private protected");
break;
default:
EmitKeyword("<Unknown-Visibility>");
break;
}
}
private void WriteVisibility(TypeMemberVisibility visibility)
{
switch (visibility)
{
case TypeMemberVisibility.Public:
WriteKeyword("public"); break;
case TypeMemberVisibility.Private:
WriteKeyword("private"); break;
case TypeMemberVisibility.Assembly:
WriteKeyword("internal"); break;
case TypeMemberVisibility.Family:
WriteKeyword("protected"); break;
case TypeMemberVisibility.FamilyOrAssembly:
WriteKeyword("protected"); WriteKeyword("internal"); break;
case TypeMemberVisibility.FamilyAndAssembly:
WriteKeyword("private"); WriteKeyword("protected"); break;
default:
WriteKeyword("<Unknown-Visibility>"); break;
}
}
public virtual void PrintTypeMemberVisibility(TypeMemberVisibility visibility)
{
switch (visibility)
{
case TypeMemberVisibility.Public:
PrintKeywordPublic();
break;
case TypeMemberVisibility.Private:
PrintKeywordPrivate();
break;
case TypeMemberVisibility.Assembly:
PrintKeywordInternal();
break;
case TypeMemberVisibility.Family:
PrintKeywordProtected();
break;
case TypeMemberVisibility.FamilyOrAssembly:
PrintKeywordProtectedInternal();
break;
case TypeMemberVisibility.FamilyAndAssembly:
default:
sourceEmitterOutput.Write("Invalid-visibility ");
break;
}
}
// this method creates a new method for the given class
public MethodDefinition createNewMethod(String methodName, NamespaceTypeDefinition methodClass, ITypeReference methodType,
TypeMemberVisibility methodVisibility, List <IParameterDefinition> methodParameters,
CallingConvention methodCallingConvention, bool isStatic, bool isAbstract, bool isVirtual)
{
// create a new method
MethodDefinition newMethod = new MethodDefinition();
newMethod.ContainingTypeDefinition = methodClass;
newMethod.InternFactory = this.host.InternFactory;
newMethod.IsCil = true;
newMethod.IsStatic = isStatic;
newMethod.Name = this.host.NameTable.GetNameFor(methodName);
newMethod.Type = methodType;
newMethod.Visibility = methodVisibility;
newMethod.IsAbstract = isAbstract;
newMethod.IsVirtual = isVirtual;
newMethod.Parameters = methodParameters;
newMethod.CallingConvention = methodCallingConvention;
// add method to class
if (methodClass.Methods == null)
{
methodClass.Methods = new List <IMethodDefinition>();
methodClass.Methods.Add(newMethod);
}
else
{
methodClass.Methods.Add(newMethod);
}
return(newMethod);
}
static ApiVisibilityEnum Extract(TypeMemberVisibility cciVisibility)
{
ApiVisibilityEnum visibility;
if (!_vmapping.TryGetValue(cciVisibility, out visibility))
{
visibility = ApiVisibilityEnum.Default;
}
return(visibility);
}
public override void TraverseChildren(IBoundExpression boundExpression) {
var tm = boundExpression.Definition as ITypeMemberReference;
if (tm != null) {
var resolvedMember = tm.ResolvedTypeDefinitionMember;
string propertyName = ContractHelper.GetStringArgumentFromAttribute(resolvedMember.Attributes, "System.Diagnostics.Contracts.ContractPublicPropertyNameAttribute");
// we don't care what it is, it just means it has a public property that represents it
// so if it is null, then it is *not* a field that has a [ContractPublicPropertyName] marking
// and so its visibility counts. If it *is* such a field, then it is considered to be public.
// (TODO: checker should make sure that the property it names is public.)
if (propertyName == null) {
this.currentVisibility = TypeHelper.VisibilityIntersection(this.currentVisibility, resolvedMember.Visibility);
}
}
base.TraverseChildren(boundExpression);
}
private TypeMemberVisibility GetInternalVisibility(TypeMemberVisibility vis)
{
if (vis == TypeMemberVisibility.Public || vis == TypeMemberVisibility.FamilyOrAssembly)
{
return(TypeMemberVisibility.Assembly);
}
else if (vis == TypeMemberVisibility.Family)
{
return(TypeMemberVisibility.FamilyAndAssembly);
}
else
{
return(vis);
}
}
public override void TraverseChildren(IBoundExpression boundExpression)
{
var tm = boundExpression.Definition as ITypeMemberReference;
if (tm != null)
{
var resolvedMember = tm.ResolvedTypeDefinitionMember;
string propertyName = ContractHelper.GetStringArgumentFromAttribute(resolvedMember.Attributes, "System.Diagnostics.Contracts.ContractPublicPropertyNameAttribute");
// we don't care what it is, it just means it has a public property that represents it
// so if it is null, then it is *not* a field that has a [ContractPublicPropertyName] marking
// and so its visibility counts. If it *is* such a field, then it is considered to be public.
// (TODO: checker should make sure that the property it names is public.)
if (propertyName == null)
{
this.currentVisibility = TypeHelper.VisibilityIntersection(this.currentVisibility, resolvedMember.Visibility);
}
}
base.TraverseChildren(boundExpression);
}
public ApiVisibility(TypeMemberVisibility cciVisibility)
{
this.Visibility = Extract(cciVisibility);
}
public static bool IsInternal(TypeMemberVisibility typeMemberVisibility)
{
return typeMemberVisibility == TypeMemberVisibility.FamilyAndAssembly || typeMemberVisibility == TypeMemberVisibility.Assembly;
}
void TypeMemberAccess(TypeMemberVisibility typeMemberVisibility) {
switch (typeMemberVisibility) {
case TypeMemberVisibility.Assembly:
this.ILDasmPaper.Keyword("assembly");
break;
case TypeMemberVisibility.Family:
this.ILDasmPaper.Keyword("family");
break;
case TypeMemberVisibility.FamilyAndAssembly:
this.ILDasmPaper.Keyword("famandassem");
break;
case TypeMemberVisibility.FamilyOrAssembly:
this.ILDasmPaper.Keyword("famorassem");
break;
case TypeMemberVisibility.Other:
this.ILDasmPaper.Keyword("compilercontrolled");
break;
case TypeMemberVisibility.Private:
this.ILDasmPaper.Keyword("private");
break;
case TypeMemberVisibility.Public:
this.ILDasmPaper.Keyword("public");
break;
case TypeMemberVisibility.Default:
default:
break;
}
}
//^ ensures this.containingTypeDeclaration == containingTypeDeclaration;
/// <summary>
/// A copy constructor that allocates an instance that is the same as the given template, except for its containing type.
/// </summary>
/// <param name="containingTypeDeclaration">The containing type of the copied member. This should be different from the containing type of the template member.</param>
/// <param name="template">The type member to copy.</param>
//^ [NotDelayed]
private FunctionDeclaration(TypeDeclaration containingTypeDeclaration, FunctionDeclaration template)
: base(template.SourceLocation)
{
this.containingTypeDeclaration = containingTypeDeclaration;
this.acceptsExtraArguments = template.AcceptsExtraArguments;
this.callingConvention = template.callingConvention;
this.isExternal = template.isExternal;
this.name = template.Name;
this.parameters = template.parameters;
this.specifiers = template.specifiers;
this.templateParameters = template.templateParameters;
this.type = (TypeExpression)template.Type.MakeCopyFor(containingTypeDeclaration.DummyBlock);
this.visibility = template.Visibility;
//^ base;
MethodContract/*?*/ contract = template.CompilationPart.Compilation.ContractProvider.GetMethodContractFor(template) as MethodContract;
if (contract != null)
this.CompilationPart.Compilation.ContractProvider.AssociateMethodWithContract(this, contract.MakeCopyFor(this.DummyBlock));
}
/// <summary>
/// Allocates a global variable.
/// </summary>
/// <param name="flags">A set of flags that specify the value of boolean properties of the field, such as IsStatic.</param>
/// <param name="visibility">Indicates if the member is public or confined to its containing type, derived types and/or declaring assembly.</param>
/// <param name="type">An expression that denote the type of value that is stored in this field.</param>
/// <param name="name">The name of the member. </param>
/// <param name="initializer">An expression that evaluates to the initial value of this field. May be null.</param>
/// <param name="sourceLocation">The source location corresponding to the newly allocated expression.</param>
public GlobalVariableDeclaration(FieldDeclaration.Flags flags, TypeMemberVisibility visibility, TypeExpression type, NameDeclaration name, Expression/*?*/ initializer, ISourceLocation sourceLocation)
: base(null, flags|FieldDeclaration.Flags.Static|FieldDeclaration.Flags.Unsafe, visibility, type, name, initializer, sourceLocation)
{
}
public static bool IsInternal(TypeMemberVisibility typeMemberVisibility)
{
return(typeMemberVisibility == TypeMemberVisibility.FamilyAndAssembly || typeMemberVisibility == TypeMemberVisibility.Assembly);
}
public virtual void EmitVisibility(TypeMemberVisibility visibility)
{
switch (visibility)
{
case TypeMemberVisibility.Public:
EmitKeyword("public");
break;
case TypeMemberVisibility.Private:
EmitKeyword("private");
break;
case TypeMemberVisibility.Assembly:
EmitKeyword("internal");
break;
case TypeMemberVisibility.Family:
EmitKeyword("protected");
break;
case TypeMemberVisibility.FamilyOrAssembly:
EmitKeyword("protected internal");
break;
case TypeMemberVisibility.FamilyAndAssembly:
default:
EmitKeyword("<Unknown-Visibility>");
break;
}
}
private TypeMemberVisibility GetInternalVisibility(TypeMemberVisibility vis)
{
if (vis == TypeMemberVisibility.Public || vis == TypeMemberVisibility.FamilyOrAssembly)
return TypeMemberVisibility.Assembly;
else if (vis == TypeMemberVisibility.Family)
return TypeMemberVisibility.FamilyAndAssembly;
else { return vis; }
}
public FunctionDefinition(MethodDeclaration.Flags flags, IEnumerable<Specifier>/*?*/ specifiers,
CallingConvention callingConvention, TypeMemberVisibility visibility, TypeExpression type, NameDeclaration name,
List<GenericMethodParameterDeclaration>/*?*/ genericParameters, List<ParameterDeclaration>/*?*/ parameters, BlockStatement/*?*/ body, bool isSpec, Expression /*?*/ expansion, ISourceLocation sourceLocation)
: base(null, flags|MethodDeclaration.Flags.Unsafe, visibility, type, name, genericParameters, parameters, body, sourceLocation)
{
this.specifiers = specifiers;
this.callingConvention = callingConvention;
this.parameters = parameters;
this.isSpec = isSpec;
this.expansion = expansion;
}
// this method creates a new method for the given class
public MethodDefinition createNewMethod(String methodName, NamespaceTypeDefinition methodClass, ITypeReference methodType,
TypeMemberVisibility methodVisibility, List<IParameterDefinition> methodParameters,
CallingConvention methodCallingConvention, bool isStatic, bool isAbstract, bool isVirtual)
{
// create a new method
MethodDefinition newMethod = new MethodDefinition();
newMethod.ContainingTypeDefinition = methodClass;
newMethod.InternFactory = this.host.InternFactory;
newMethod.IsCil = true;
newMethod.IsStatic = isStatic;
newMethod.Name = this.host.NameTable.GetNameFor(methodName);
newMethod.Type = methodType;
newMethod.Visibility = methodVisibility;
newMethod.IsAbstract = isAbstract;
newMethod.IsVirtual = isVirtual;
newMethod.Parameters = methodParameters;
newMethod.CallingConvention = methodCallingConvention;
// add method to class
if (methodClass.Methods == null) {
methodClass.Methods = new List<IMethodDefinition>();
methodClass.Methods.Add(newMethod);
}
else {
methodClass.Methods.Add(newMethod);
}
return newMethod;
}
public FunctionDeclaration(bool acceptsExtraArguments, IEnumerable<Specifier>/*?*/ specifiers, bool isExternal, CallingConvention callingConvention, TypeMemberVisibility visibility, TypeExpression type, NameDeclaration name,
List<GenericMethodParameterDeclaration>/*?*/ templateParameters, List<ParameterDeclaration>/*?*/ parameters, bool isSpec, Expression /*?*/ expansion, ISourceLocation sourceLocation)
: base(sourceLocation)
{
this.acceptsExtraArguments = acceptsExtraArguments;
this.callingConvention = callingConvention;
this.isExternal = isExternal;
this.name = name;
this.parameters = parameters;
this.specifiers = specifiers;
this.templateParameters = templateParameters;
this.type = type;
this.visibility = visibility;
this.isSpec = isSpec;
this.expansion = expansion;
}
