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; } }
// 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 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; }