public bool? IsExposedMember(Member member) {
if (member.Name.Name == name) {
return (exposed);
} else {
return (null);
}
}
/// <summary>
/// Checks for less-than-visible member references in an expression.
/// </summary>
public override void VisitMemberBinding(MemberBinding binding)
{
if (binding == null) return;
Member mem = binding.BoundMember;
if (mem != null)
{
Field f = mem as Field;
bool specPublic = false;
if (f != null)
{
specPublic = IsSpecPublic(f);
}
if (!specPublic && !HelperMethods.IsCompilerGenerated(mem))
{
// F: It seems there is some type-state like invariant here justifying why this.AsThisMemeber != null
Contract.Assume(this.AsThisMember != null);
if (!HelperMethods.IsReferenceAsVisibleAs(mem, this.AsThisMember))
{
this.memberInErrorFound = mem;
return;
}
}
}
base.VisitMemberBinding(binding);
}
public override bool IsExposedMember(Member member) {
// member of delegates are not exposed
TypeNode type = member.DeclaringType;
if (type.NodeType == NodeType.DelegateNode) return (false);
// accessor methods for properties and events are not exposed
if (member.IsSpecialName && (member.NodeType == NodeType.Method)) {
string name = member.Name.Name;
if (NameContains(name, "get_")) return (false);
if (NameContains(name, "set_")) return (false);
if (NameContains(name, "add_")) return (false);
if (NameContains(name, "remove_")) return (false);
if (NameContains(name, "raise_")) return (false);
}
// the value field of enumerations is not exposed
if (member.IsSpecialName && (type.NodeType == NodeType.EnumNode) && (member.NodeType == NodeType.Field)) {
string name = member.Name.Name;
if (name == "value__") return (false);
}
// members marked as compiler-generated are not exposed
if (ListContainsAttribute(member.Attributes, "System.Runtime.CompilerServices.CompilerGeneratedAttribute")) {
return (false);
}
// okay, passed all tests, so member is exposed
return (base.IsExposedMember(member));
}
// exposure logic for artibrary APIs
// call the appropriate particular exposure logic
public virtual bool IsExposedApi(Member api) {
Namespace space = api as Namespace;
if (space != null) return (IsExposedNamespace(space));
TypeNode type = api as TypeNode;
if (type != null) return (IsExposedType(type));
return (IsExposedMember(api));
}
public void CheckModelfieldAdmissibility(ModelfieldContract mfC) {
this.DeclaringMfC = mfC;
this.DeclaringMember = mfC.Modelfield;
if (this.DeclaringMember is Property)
this.DeclaringMember = (this.DeclaringMember as Property).Getter; //references to the modelfield have been resolved as bindings to this getter
foreach (Expression satExpr in mfC.SatisfiesList) {
StateStack = new System.Collections.Stack();
ResetCurrentState();
this.VisitExpression(satExpr);
}
}
public virtual string GetApiName(Member api) {
Namespace space = api as Namespace;
if (space != null) return (GetNamespaceName(space));
TypeNode type = api as TypeNode;
if (type != null) return (GetTypeName(type));
return (GetMemberName(api));
}
public virtual Member VisitMemberReference(Member member)
{
if(member == null)
return null;
TypeNode specializedType = this.VisitTypeReference(member.DeclaringType);
if(specializedType == member.DeclaringType || specializedType == null)
return member;
return Specializer.GetCorrespondingMember(member, specializedType);
}
public bool? IsExposedMember(Member member) {
//Console.WriteLine("DEBUG: typeFilter.IsExposedMember");
TypeNode type = ReflectionUtilities.GetTemplateType(member.DeclaringType);
if (IsExposedType(type) != null) {
foreach (MemberFilter memberFilter in memberFilters) {
bool? result = memberFilter.IsExposedMember(member);
if (result != null) return (result);
}
return (exposed); //return the type's exposed setting
} else {
return (null);
}
}
//=====================================================================
/// <summary>
/// Check to see if the member is exposed or not by this entry
/// </summary>
/// <param name="member">The member to check</param>
/// <returns>Null if the member is not represented by this entry, true if it is and it is exposed or
/// false if it is and it is not exposed.</returns>
public bool? IsExposedMember(Member member)
{
// Try for an exact match first
if(member.Name.Name == name)
return exposed;
// !EFW - If the member name contains "<" and our name contains "{", this is probably a
// generic using the XML comments syntax member ID so try for a match that way too.
if(member.Name.Name.IndexOf('<') != -1 && name.IndexOf('{') != -1 &&
member.Name.Name.Replace('<', '{').Replace('>', '}') == name)
return exposed;
return null;
}
private static string GetName(Member entity) {
using (TextWriter writer = new StringWriter()) {
TypeNode type = entity as TypeNode;
if (type != null) {
writer.Write("T:");
WriteType(type, writer);
return (writer.ToString());
}
switch (entity.NodeType) {
case NodeType.Namespace:
writer.Write("N:");
WriteNamespace(entity as Namespace, writer);
break;
case NodeType.Field:
writer.Write("F:");
WriteField(entity as Field, writer);
break;
case NodeType.Property:
writer.Write("P:");
WriteProperty(entity as Property, writer);
break;
case NodeType.Method:
writer.Write("M:");
WriteMethod(entity as Method, writer);
break;
case NodeType.InstanceInitializer:
writer.Write("M:");
WriteConstructor(entity as InstanceInitializer, writer);
break;
case NodeType.StaticInitializer:
writer.Write("M:");
WriteStaticConstructor(entity as StaticInitializer, writer);
break;
case NodeType.Event:
writer.Write("E:");
WriteEvent(entity as Event, writer);
break;
}
return (writer.ToString());
}
}
public override bool IsExposedMember(Member member)
{
if (member == null) throw new ArgumentNullException("member");
TypeNode type = member.DeclaringType;
// if the member isn't visible, we certainly won't expose it...
if (!member.IsVisibleOutsideAssembly && !(protectedSealedVisible && type.IsSealed && (member.IsFamily || member.IsFamilyOrAssembly)))
return (false);
// ...but there are also some visible members we won't expose.
// member of delegates are not exposed
if (type.NodeType == NodeType.DelegateNode) return (false);
// accessor methods for properties and events are not exposed
if (member.IsSpecialName && (member.NodeType == NodeType.Method))
{
string name = member.Name.Name;
if (NameContains(name, "get_")) return (false);
if (NameContains(name, "set_")) return (false);
if (NameContains(name, "add_")) return (false);
if (NameContains(name, "remove_")) return (false);
if (NameContains(name, "raise_")) return (false);
}
// the value field of enumerations is not exposed
if (member.IsSpecialName && (type.NodeType == NodeType.EnumNode) && (member.NodeType == NodeType.Field))
{
string name = member.Name.Name;
if (name == "value__") return (false);
}
// protected members of sealed types are not exposed
// change of plan -- yes they are
// if (type.IsSealed && (member.IsFamily || member.IsFamilyOrAssembly)) return(false);
// One more test to deal with a wierd case: a private method is an explicit implementation for
// a property accessor, but is not marked with the special name flag. To find these, test for
// the accessibility of the methods they implement
if (member.IsPrivate && member.NodeType == NodeType.Method)
{
Method method = (Method)member;
MethodList implements = method.ImplementedInterfaceMethods;
if ((implements.Count > 0) && (!IsExposedMember(implements[0]))) return (false);
}
// okay, passed all tests, the member is exposed as long as the filters allow it
return (base.IsExposedMember(member));
}
public bool? IsExposedMember(Member member) {
//Console.WriteLine("DEBUG: namespaceFilter.isExposedMemeber");
TypeNode type = ReflectionUtilities.GetTemplateType(member.DeclaringType);
Namespace space = ReflectionUtilities.GetNamespace(type);
if (IsExposedNamespace(space) != null) {
foreach (TypeFilter typeFilter in typeFilters) {
bool? result = typeFilter.IsExposedMember(member);
if (result != null) return (result);
}
//no filters matched this method, check if the type is exposed
bool? typeIsExposed = IsExposedType(type);
if (typeIsExposed != null) return typeIsExposed;
return (exposed); //if the namespace is exposed
} else {
return (null);
}
}
public static Member GetTemplateMember(Member member) {
if (member == null) throw new ArgumentNullException("member");
// if the containing type isn't generic, the member is the template member
TypeNode type = member.DeclaringType;
if (!type.IsGeneric) return (member);
// if the containing type isn't specialized, the member is the template member
if (!IsSpecialized(type)) return (member);
// get the template type, and look for members with the same name
TypeNode template = ReflectionUtilities.GetTemplateType(member.DeclaringType);
Identifier name = member.Name;
MemberList candidates = template.GetMembersNamed(name);
// if no candidates, say so (this shouldn't happen)
if (candidates.Count == 0) throw new InvalidOperationException("No members in the template had the name found in the specialization. This is not possible, but apparently it happened.");
// if only one candidate, return it
if (candidates.Count == 1) return (candidates[0]);
// multiple candidates, so now we need to compare parameters
ParameterList parameters = GetParameters(member);
for (int i = 0; i < candidates.Count; i++) {
Member candidate = candidates[i];
// candidate must be same kind of node
if (candidate.NodeType != member.NodeType) continue;
// if parameters match, this is the one
if (ParametersMatch(parameters, GetParameters(candidate))) return (candidate);
}
Console.WriteLine(member.DeclaringType.FullName);
Console.WriteLine(member.FullName);
throw new InvalidOperationException("No members in the template matched the parameters of the specialization. This is not possible.");
}
/// <inheritdoc />
public override string GetMemberName(Member member)
{
StringBuilder sb = new StringBuilder();
switch(member.NodeType)
{
case NodeType.Field:
sb.Append("F:");
WriteField((Field)member, sb);
break;
case NodeType.Property:
sb.Append("P:");
WriteProperty((Property)member, sb);
break;
case NodeType.Event:
sb.Append("E:");
WriteEvent((Event)member, sb);
break;
case NodeType.Method:
sb.Append("M:");
WriteMethod((Method)member, sb);
break;
case NodeType.InstanceInitializer:
sb.Append("M:");
WriteConstructor((InstanceInitializer)member, sb);
break;
case NodeType.StaticInitializer:
sb.Append("M:");
WriteStaticConstructor((StaticInitializer)member, sb);
break;
}
return sb.ToString();
}
public override string GetMemberName(Member member) {
using (TextWriter writer = new StringWriter()) {
switch (member.NodeType) {
case NodeType.Field:
writer.Write("F:");
WriteField((Field)member, writer);
break;
case NodeType.Property:
writer.Write("P:");
WriteProperty((Property)member, writer);
break;
case NodeType.Method:
writer.Write("M:");
WriteMethod((Method)member, writer);
break;
case NodeType.InstanceInitializer:
writer.Write("M:");
WriteConstructor((InstanceInitializer)member, writer);
break;
case NodeType.StaticInitializer:
writer.Write("M:");
WriteStaticConstructor((StaticInitializer)member, writer);
break;
case NodeType.Event:
writer.Write("E:");
WriteEvent((Event)member, writer);
break;
}
return (writer.ToString());
}
}
private void WriteDeclarationSourceContext(Member m, char definitionStart) {
int startLine = m.SourceContext.StartLine;
int startPos = m.SourceContext.StartPos;
GetAttributesStartPos(m.Attributes, ref startLine, ref startPos);
int defStartPos = m.SourceContext.SourceText.IndexOf(definitionStart);
int declEnd;
if (defStartPos >= 0) {
// found definition start.
declEnd = m.SourceContext.StartPos + defStartPos;
}
else {
// no open brace, meaning it's probably abstract and we should include the whole thing
// in the declaration.
declEnd = m.SourceContext.EndPos;
}
SourceContext declEndContext = m.SourceContext;
declEndContext.EndPos = declEnd;
this.writer.WriteAttributeString("declStartLine", startLine.ToString());
this.writer.WriteAttributeString("declEndLine", declEndContext.EndLine.ToString());
this.writer.WriteAttributeString("declStartPos", startPos.ToString());
this.writer.WriteAttributeString("declEndPos", declEnd.ToString());
}
void AddReadAllGroup(Class serializer, Block block, TypeNode type, StatementList statements, Identifier reader,
Expression target, Expression required, Expression result, ArrayList members, Member mixedMember) {
// todo: keep track of which members have been read and report error on duplicates
MethodCall read = new MethodCall(new QualifiedIdentifier(reader, Identifier.For("Read")), new ExpressionList());
Local sb = new Local(SystemTypes.StringBuilder);
bool isMixed = mixedMember != null;
if (isMixed) {
statements.Add(new AssignmentStatement(sb,
new Construct(new MemberBinding(null, SystemTypes.StringBuilder), new ExpressionList(), SystemTypes.StringBuilder)));
}
Block whileBody = new Block(new StatementList());
BinaryExpression notEndTag = new BinaryExpression(
new QualifiedIdentifier(reader, Identifier.For("NodeType")) ,
new QualifiedIdentifier(Identifier.For("XmlNodeType"), Identifier.For("EndElement")), NodeType.Ne);
BinaryExpression notEOF = new BinaryExpression(
new QualifiedIdentifier(reader, Identifier.For("EOF")), Literal.True, NodeType.Ne);
While w = new While(new BinaryExpression(notEndTag, notEOF, NodeType.And), whileBody);
statements.Add(w);
Local nameLocal = new Local(Identifier.For("name"),SystemTypes.String,block);
Local nsLocal = new Local(Identifier.For("ns"),SystemTypes.String,block);
Local nodeType = new Local(Identifier.For("nodeType"),Runtime.XmlNodeType,block);
whileBody.Statements.Add(new AssignmentStatement(nameLocal, new QualifiedIdentifier(reader, Identifier.For("LocalName"))));
whileBody.Statements.Add(new AssignmentStatement(nsLocal, new QualifiedIdentifier(reader, Identifier.For("NamespaceURI"))));
whileBody.Statements.Add(new AssignmentStatement(nodeType, new QualifiedIdentifier(reader, Identifier.For("NodeType"))));
Block childBlock = whileBody;
if (isMixed) {
// Append the text node to the current StringBuilder contents.
childBlock = new Block(new StatementList());
If ifText = new If(IsTextNode(nodeType), new Block(new StatementList()), childBlock);
whileBody.Statements.Add(ifText);
ExpressionList args = new ExpressionList();
args.Add(new QualifiedIdentifier(reader, Identifier.For("Value")));
ifText.TrueBlock.Statements.Add(new ExpressionStatement(new MethodCall(
new QualifiedIdentifier(sb, Identifier.For("Append")), args)));
ifText.TrueBlock.Statements.Add(new ExpressionStatement(read)); // advance to next node
}
If ifElement = new If(new BinaryExpression(nodeType,
new QualifiedIdentifier(Identifier.For("XmlNodeType"), Identifier.For("Element")), NodeType.Eq),
new Block(new StatementList()), new Block(new StatementList()));
childBlock.Statements.Add(ifElement);
childBlock = ifElement.TrueBlock;
//AddConsoleWrite(statements, new Literal("name=",SystemTypes.String));
//AddConsoleWriteLine(statements, nameLocal);
//AddConsoleWrite(statements, new Literal("nodeType=",SystemTypes.String));
//AddConsoleWriteLine(statements, nodeType);
foreach (NamedNode childNode in members) {
if (!(childNode.Member is Field || childNode.Member is Property)) {
AddError(statements, reader, RuntimeError.SerializationOfTypeNotSupported,
new Literal(childNode.Member.GetType().FullName, SystemTypes.String));
} else {
Expression mb = GetMemberBinding(target, childNode.Member);
childBlock = AddReadChild(block, childBlock.Statements, childNode.Name, childNode.TypeNode, mb, reader, result, true, false).FalseBlock;
// todo: throw error if child is required. (e.g. NonEmptyIEnumerable...)
}
}
// if it isn't any of the expected elements then throw an error.
AddError(childBlock.Statements, reader, RuntimeError.NoSuchMember,
new Expression[2]{new Literal(tempChecker.GetTypeName(type),SystemTypes.String), nameLocal});
// If it's not an element then consume it anyway to keep the reader advancing.
// Probably a comment or PI or something.
ifElement.FalseBlock.Statements.Add(new ExpressionStatement(new MethodCall(
new QualifiedIdentifier(reader, Identifier.For("Skip")), new ExpressionList())));
if (isMixed) {
statements.Add(new AssignmentStatement(GetMemberBinding(target, mixedMember),
new MethodCall(new QualifiedIdentifier(sb, Identifier.For("ToString")), new ExpressionList())));
}
statements.Add(new AssignmentStatement(result, Literal.True));
}
MemberBinding GetMemberBinding(Expression source, Member m, TypeNode t) {
MemberBinding src = new MemberBinding(source, m);
src.Type = t;
return src;
}
void AddWriteMember(Member child, Identifier name, StatementList statements, TypeNode referringType, Expression src, Identifier writer, bool emptyElementOnNull) {
src = GetMemberBinding(src, child);
TypeNode type = src.Type;
if (type == null) return;
if (type.Template == SystemTypes.GenericBoxed) {
statements = AddCheckForNull(statements, Duplicate(src, referringType), type);
type = Checker.GetCollectionElementType(type);
src = CastTo(src, type);//unbox it
}
if (child.IsAnonymous) {
if (type is TypeAlias) {
TypeAlias alias = (TypeAlias)type;
src = CastTo(src, alias.AliasedType); //unbox it
AddWriteElement(statements, referringType, writer, alias.Name, src, alias.AliasedType, emptyElementOnNull);
} else if (!AddWriteSimpleType(type, statements, referringType, writer, src, Literal.Null, Literal.Null)) {
if (type is TupleType || type is TypeUnion || IsStream(type)) {
AddCallSerializer(type, statements, src, writer, Literal.Null, Literal.Null);
} else {
AddWriteElement(statements, referringType, writer, type.Name, src, type, emptyElementOnNull);
}
}
} else if (type is TypeAlias) {
TypeAlias alias = (TypeAlias)type;
src = CastTo(src, alias.AliasedType); //unbox it
AddWriteElement(statements, referringType, writer, name, src, alias.AliasedType, emptyElementOnNull);
} else {
AddWriteElement(statements, referringType, writer, name, src, type, emptyElementOnNull);
}
}
void AddReadOptional(Block block, StatementList statements, Member mem, Expression target, Identifier reader, Expression result) {
TypeNode boxed = Checker.GetMemberType(mem);
TypeNode type = Checker.GetCollectionElementType(boxed);
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(reader, Identifier.For("MoveToContent")), new ExpressionList())));
Local nameLocal = new Local(Identifier.For("name"),SystemTypes.String, block);
Local nsLocal = new Local(Identifier.For("ns"),SystemTypes.String, block);
statements.Add(new AssignmentStatement(nameLocal, new QualifiedIdentifier(reader, Identifier.For("LocalName"))));
statements.Add(new AssignmentStatement(nsLocal, new QualifiedIdentifier(reader, Identifier.For("NamespaceURI"))));
StringBuilder expecting = new StringBuilder();
Expression isFound = null;
if (mem.IsAnonymous) {
isFound = IsStartOf(block, type, statements, nameLocal, nsLocal, expecting);
} else {
ExpressionList args = new ExpressionList();
args.Add(new Literal(mem.Name.Name, SystemTypes.String));
isFound = new MethodCall(new QualifiedIdentifier(reader, Identifier.For("IsStartElement")), args);
}
StatementList trueStatements = new StatementList();
If ifIsFound = new If(isFound, new Block(trueStatements), null);
statements.Add(ifIsFound);
if (!AddReadSimpleType(type, trueStatements, reader, target, result, false)) {
Local localRequired = new Local(Identifier.Empty,SystemTypes.Boolean,block);
statements.Add(new AssignmentStatement(localRequired, Literal.True));
AddCallDeserializer(type, trueStatements, reader, target, localRequired, result);
}
}
MemberBinding GetMemberBinding(Expression source, Member m) {
MemberBinding src = new MemberBinding(source, m);
src.Type = Checker.GetMemberType(m);
return src;
}
internal static void TryAddDebuggerBrowsableNeverAttribute(Member member, System.AttributeTargets targets)
{
Contract.Requires(member != null);
try
{
if (HelperMethods.debuggerBrowsableAttributeNode == null) return;
if (HelperMethods.debuggerBrowsableStateType == null) return;
var ctor = HelperMethods.debuggerBrowsableAttributeNode.GetConstructor(HelperMethods.debuggerBrowsableStateType);
var args = new ExpressionList(Literal.Int32Zero);
var attribute = new AttributeNode(new MemberBinding(null, ctor), args, targets);
member.Attributes.Add(attribute);
}
catch
{ }
}
internal static void TryAddCompilerGeneratedAttribute(Member member, System.AttributeTargets targets)
{
Contract.Requires(member != null);
if (HelperMethods.compilerGeneratedAttributeNode == null) return;
Member compilerGenerated = HelperMethods.compilerGeneratedAttributeNode.GetConstructor();
AttributeNode compilerGeneratedAttribute = new AttributeNode(new MemberBinding(null, compilerGenerated), null, targets);
member.Attributes.Add(compilerGeneratedAttribute);
}
/// <summary>
/// This is used to visit a member
/// </summary>
/// <param name="member">The member to visit</param>
protected virtual void VisitMember(Member member)
{
this.VisitEntity(member);
}
/// <summary>
/// This method can be overridden in derived classes to handle common tasks that should occur before an
/// API member of any kind is visited.
/// </summary>
/// <param name="entity">The entity to be visited</param>
/// <remarks>The default implementation does nothing</remarks>
protected virtual void VisitEntity(Member entity)
{
}
public override bool LanguageSpecificSupression(Member m){
Debug.Assert(m != null);
Method meth = m as Method;
if (meth != null && meth.Name.UniqueIdKey == StandardIds.Finalize.UniqueIdKey && meth.ReturnType == SystemTypes.Void && (meth.Parameters == null || meth.Parameters.Count == 0))
return true;
return false;
}
/// <summary> /// This method is used to get the member name /// </summary> /// <param name="space">The member for which to get the name</param> /// <returns>The member name</returns> public abstract string GetMemberName(Member member);
public static Module AssemblyOf(Member m)
{
Contract.Requires(m != null);
TypeNode t = m as TypeNode;
if (t == null)
{
t = m.DeclaringType;
Contract.Assume(t != null, "non-types must have a declaring type");
}
while (t.DeclaringType != null)
{
t = t.DeclaringType;
}
return t.DeclaringModule;
}
public static Member GetCorrespondingMember(Member/*!*/ member, TypeNode/*!*/ specializedType)
{
//member belongs to a structural type based on a type parameter.
//return the corresponding member from the structural type based on the type argument.
if (member.DeclaringType == null) { Debug.Fail(""); return null; }
MemberList unspecializedMembers = member.DeclaringType.Members;
MemberList specializedMembers = specializedType.Members;
if (unspecializedMembers == null || specializedMembers == null) { Debug.Assert(false); return null; }
int unspecializedOffset = 0;
int specializedOffset = 0;
//The offsets can become > 0 when the unspecialized type and/or specialized type is imported from another assembly
//(and the unspecialized type is in fact a partially specialized type.)
for (int i = 0, n = specializedMembers == null ? 0 : specializedMembers.Count; i < n; i++)
{
Member unspecializedMember = unspecializedMembers[i - unspecializedOffset];
Member specializedMember = specializedMembers[i - specializedOffset];
if (unspecializedMember != null && specializedMember == null && unspecializedOffset == i &&
!(unspecializedMember is TypeParameter || unspecializedMember is ClassParameter))
{
unspecializedOffset++; continue; //Keep current unspecialized member, skip over null specialized member
}
if (unspecializedMember == null && specializedMember != null && specializedOffset == i &&
!(specializedMember is TypeParameter || specializedMember is ClassParameter))
{
specializedOffset++; continue; //Keep current specialized member, skip over null
}
if (unspecializedMember == member)
{
Debug.Assert(specializedMember != null);
return specializedMember;
}
}
Debug.Assert(false);
return null;
}
public override string GetInstanceMemberSignature(Member mem)
{
Field f = mem as Field;
Method m = mem as Method;
TypeNode mType = f != null ? f.Type : m != null ? m.ReturnType : null;
string mName = mem.Name.ToString();
return this.GetTypeName(mType) + " this." + mName;
}
