public ClassDecl(Cursor c, ISymbolTable table)
: base(c, table)
{
Debug.Assert(CursorKinds.IsClassStructEtc(c.Kind));
_templateKind = Symbols.TemplateKind.NonTemplate;
if (c.Kind == CursorKind.ClassTemplate)
_templateKind = Symbols.TemplateKind.Template;
else if (c.Kind == CursorKind.ClassTemplatePartialSpecialization)
_templateKind = Symbols.TemplateKind.TemplatePartialSpecialization;
else if (c.TemplateSpecialisedCursorTemplate != null)
_templateKind = Symbols.TemplateKind.TemplateSpecialization;
if(c.SemanticParentCurosr.Kind == CursorKind.Namespace)
{
_parent = table.FindNamespaceDeclaration(c.SemanticParentCurosr.Usr);
Debug.Assert(_parent != null);
}
else if (c.SemanticParentCurosr.Kind == CursorKind.TranslationUnit ||
c.SemanticParentCurosr.Kind == CursorKind.UnexposedDecl)
{
_parent = null;
}
else if(CursorKinds.IsClassStructEtc(c.SemanticParentCurosr.Kind))
{
_parent = table.FindClassDeclaration(c.SemanticParentCurosr.Usr);
Debug.Assert(_parent != null);
}
else
{
Debug.Assert(false);
}
}
public Reference(Cursor c, IDeclaration decl, ISymbolTable table)
{
_cursor = c;
_decl = decl;
_table = table;
_location = new CodeLocation(c.Extent.Start); //todo - replace for doc tracking
}
public VariableDecl(Cursor c, ISymbolTable table)
: base(c, table)
{
// Debug.Assert(c.Kind == CursorKind.VarDecl);
if (c.SemanticParentCurosr.Kind == CursorKind.Namespace)
{
_parent = table.FindNamespaceDeclaration(c.SemanticParentCurosr.Usr);
Debug.Assert(_parent != null);
}
else if (CursorKinds.IsClassStructEtc(c.SemanticParentCurosr.Kind))
{
_parent = table.FindClassDeclaration(c.SemanticParentCurosr.Usr);
Debug.Assert(_parent != null);
}
else if(CursorKinds.IsFunctionEtc(c.SemanticParentCurosr.Kind))
{
_parent = table.FindFunctionDeclaration(c.SemanticParentCurosr.Usr);
}
else if (c.SemanticParentCurosr.Kind == CursorKind.TranslationUnit ||
c.SemanticParentCurosr.Kind == CursorKind.UnexposedDecl)
{
_parent = null;
}
else
{
Debug.Assert(false);
}
}
protected override IList<string> CalculateQuickSearchTexts(IDeclaration declaration) {
if (!declaration.IsValid())
return EmptyList<string>.InstanceList;
var owner = declaration as IInterfaceQualificationOwner;
if (owner != null && owner.InterfaceQualificationReference != null)
return new[] { owner.GetDeclaredShortName(), owner.InterfaceQualificationReference.ShortName };
var constructorDeclaration = declaration as IConstructorDeclaration;
if (constructorDeclaration != null)
return new[] { constructorDeclaration.DeclaredName, "new", "ctor" };
var indexerDeclaration = declaration as IIndexerDeclaration;
if (indexerDeclaration != null)
return new[] { indexerDeclaration.DeclaredName, "this" };
var destructorDeclaration = declaration as IDestructorDeclaration;
if (destructorDeclaration != null)
return new[] { destructorDeclaration.DeclaredName, "Finalize" };
var operatorDeclaration = declaration as IOperatorDeclaration;
if (operatorDeclaration != null)
return new[] { operatorDeclaration.DeclaredName, "operator" };
var eventDeclaration = declaration as IEventDeclaration;
if (eventDeclaration != null)
return new[] { eventDeclaration.DeclaredName, "event" };
return base.CalculateQuickSearchTexts(declaration);
}
public PsiIntentionResult(List<ITemplateFieldHolder> holders, IDeclaration declaration, ITreeNode anchor, DocumentRange range)
{
myDeclaration = declaration;
myHolders = holders;
myPrefferedSelection = range;
myAnchor = anchor;
}
public NTriplesIntentionResult(
List<ITemplateFieldHolder> holders, IDeclaration declaration, ITreeNode anchor, DocumentRange range)
{
this.myDeclaration = declaration;
this.myHolders = holders;
this.myPreferredSelection = range;
this.myAnchor = anchor;
}
public void SetUp()
{
mocks = new MockRepository();
objectBuilder = mocks.DynamicMock<IObjectBuilder<MyClass>>();
operable = mocks.DynamicMultiMock<IDeclaration<MyClass>>(typeof(IOperable<MyClass>));
func = x => x.Float = 1f;
propertyExpression = x => x.IntGetterOnly;
}
private DeclarationViewModel FindOrAddParentNode(IDeclaration decl)
{
if(decl is NamespaceDecl)
return FindOrAddNamespaceNode(decl as NamespaceDecl);
if(decl is ClassDecl)
return FindOrAddClassNode(decl as ClassDecl);
return null;
}
protected void Page_Load(object sender, EventArgs e)
{
_declaration = new ApplicationFactory(_loginName, _ipAddress).CreateDeclarationApplication();
if (!IsPostBack)
{
ccmbTerm.DoDataBind();
}
}
public void Check(IDeclaration declaration, INamingPolicyProvider namingPolicyProvider, out bool isFinalResult, out NamingConsistencyCheckResult result)
{
isFinalResult = false;
var methodDeclaration = declaration as IMethodDeclaration;
var method = methodDeclaration?.DeclaredElement;
if (method != null)
{
var unityApi = method.GetSolution().GetComponent<UnityApi>();
isFinalResult = unityApi.IsEventFunction(method);
}
result = isFinalResult ? NamingConsistencyCheckResult.OK : null;
}
public void SetUp()
{
mocks = new MockRepository();
declarations = new DeclarationQueue<MyClass>(listSize);
declaration1 = mocks.DynamicMock<IDeclaration<MyClass>>();
declaration2 = mocks.DynamicMock<IDeclaration<MyClass>>();
globalDeclaration = mocks.DynamicMock<IGlobalDeclaration<MyClass>>();
using (mocks.Record())
{
declaration1.Stub(x => x.Start).Return(0).Repeat.Any();
declaration1.Stub(x => x.End).Return(10).Repeat.Any();
}
}
protected override IEnumerable <IType> GetRelatedTypes(IDeclaration declaration)
{
if (declaration is ITypeDeclaration)
{
return(this.GetSuperTypes(declaration as ITypeDeclaration).Cast <IType>());
}
var fieldDeclaration = declaration as IFieldDeclaration;
if (fieldDeclaration != null)
{
return(new[] { fieldDeclaration.Type });
}
var parameterDeclaration = declaration as IParameterDeclaration;
if (parameterDeclaration != null)
{
return(new[] { parameterDeclaration.Type });
}
var propertyDeclaration = declaration as IPropertyDeclaration;
if (propertyDeclaration != null)
{
return(new[] { propertyDeclaration.Type });
}
var variableDeclaration = declaration as ILocalVariableDeclaration;
if (variableDeclaration != null)
{
return(new[] { variableDeclaration.Type });
}
var methodDeclaration = declaration as IMethodDeclaration;
if (methodDeclaration != null)
{
return(new List <IType>(methodDeclaration.ParameterDeclarations.Select(x => x.Type))
{
methodDeclaration.Type
});
}
return(Enumerable.Empty <IType>());
}
public IUnitTestElement CreateContext(string assemblyPath, IDeclaration declaration)
{
var type = (ITypeElement) declaration.DeclaredElement;
var context = GetOrCreateContext(assemblyPath,
declaration.GetProject(),
type.GetClrName().GetPersistent(),
type.GetSubjectString(),
type.GetTags(), type.IsIgnored());
foreach (var child in context.Children)
{
child.State = UnitTestElementState.Pending;
}
_cache.AddContext(type, context);
return context;
}
public override ISet <IMethodDeclaration> getStaticMemberMethods(Context context, String name)
{
IDeclaration decl = getDeclaration(context);
if (decl is EnumeratedCategoryDeclaration || decl is EnumeratedNativeDeclaration)
{
return(decl.GetIType(context).getStaticMemberMethods(context, name));
}
else if (decl is SingletonCategoryDeclaration)
{
return(decl.GetIType(context).getMemberMethods(context, name));
}
else
{
return(base.getStaticMemberMethods(context, name));
}
}
public IDeclaration Resolve(string symbol)
{
IDeclaration local = ResolveHere(symbol);
if (local != null)
{
return(local);
}
else if (parentScope != null)
{
return(parentScope.Resolve(symbol));
}
else
{
return(null);
}
}
public override IValue getStaticMemberValue(Context context, String name)
{
IDeclaration decl = context.getRegisteredDeclaration <IDeclaration>(GetTypeName());
if (!(decl is IEnumeratedDeclaration <CategorySymbol>))
{
throw new SyntaxError(name + " is not an enumerated type!");
}
if ("symbols" == name)
{
return(((IEnumeratedDeclaration <CategorySymbol>)decl).getSymbols());
}
else
{
return(base.getStaticMemberValue(context, name));
}
}
private Value visitOnDeclaration(IDeclaration decl)
{
switch (decl.Type)
{
case Nodes.ClassDeclaration:
case Nodes.ExportAllDeclaration:
case Nodes.ExportDefaultDeclaration:
case Nodes.ExportNamedDeclaration:
case Nodes.FunctionDeclaration:
case Nodes.ImportDeclaration:
case Nodes.VariableDeclaration:
break;
}
// never triggered.
throw new InvalidOperationException();
}
public override IValue ConvertCSharpValueToIValue(Context context, object value)
{
IDeclaration decl = getDeclaration(context);
if (decl is EnumeratedNativeDeclaration || decl is EnumeratedCategoryDeclaration)
{
return(LoadEnumValue(context, decl, value));
}
else if (decl is CategoryDeclaration)
{
return(ConvertCSharpValueToIValue(context, (CategoryDeclaration)decl, value));
}
else
{
return(base.ConvertCSharpValueToIValue(context, value));
}
}
public ConcreteMethodDeclaration getInitializeMethod(Context context)
{
registerMethods(context);
if (methodsMap.ContainsKey("initialize"))
{
IDeclaration decl = methodsMap["initialize"];
if (decl is MethodDeclarationMap)
{
IMethodDeclaration method = ((MethodDeclarationMap)decl).GetFirst();
if (method is ConcreteMethodDeclaration)
{
return((ConcreteMethodDeclaration)method);
}
}
}
return(null);
}
private IExpression resolveUnresolvedDeclaration(Context context, string name)
{
IDeclaration decl = context.getRegisteredDeclaration <IDeclaration>(name);
if (decl == null)
{
return(null);
}
else if (decl is CategoryDeclaration)
{
return(new ConstructorExpression(new CategoryType(name), null, arguments));
}
else
{
return(new MethodCall(new MethodSelector(name), arguments));
}
}
/// <summary>
/// Generate a declaration use.
/// </summary>
/// <param name="declaration">The used declaration.</param>
/// <param name="typeSourceCode">The type source code.</param>
/// <param name="setup">The action delegate to do additional setup on the mock.</param>
/// <returns>The mocked declaration use.</returns>
public static TDeclarationUse SetupDeclarationUse <TDeclarationUse>(IDeclaration <SyntaxNode> declaration, string typeSourceCode = null, Action <Mock <TDeclarationUse> > setup = null)
where TDeclarationUse : class, IDeclarationUse <SyntaxNode>
{
var propertyTypeMock = new Mock <TDeclarationUse>();
propertyTypeMock.Setup(t => t.Declaration).Returns(declaration);
if (typeSourceCode != null)
{
var typeNode = SyntaxTreeHelper.GetTypeSyntax(typeSourceCode);
var nodeProvider = SyntaxTreeHelper.GetSyntaxNodeProvider(typeNode);
propertyTypeMock.Setup(t => t.SyntaxNodeProvider).Returns(nodeProvider);
}
setup?.Invoke(propertyTypeMock);
return(propertyTypeMock.Object);
}
public override IValue getStaticMemberValue(Context context, String name)
{
IDeclaration decl = context.getRegisteredDeclaration <IDeclaration>(this.typeName);
if (!(decl is EnumeratedNativeDeclaration))
{
throw new SyntaxError(name + " is not an enumerated type!");
}
if ("symbols" == name)
{
return(((EnumeratedNativeDeclaration)decl).getSymbols());
}
else
{
throw new SyntaxError("Unknown member:" + name);
}
}
public IUnitTestElement CreateContext(string assemblyPath, IDeclaration declaration)
{
var type = (ITypeElement)declaration.DeclaredElement;
var context = this.GetOrCreateContext(assemblyPath,
declaration.GetProject(),
type.GetClrName().GetPersistent(),
type.GetSubjectString(),
type.GetTags(), type.IsIgnored());
foreach (var child in context.Children)
{
child.State = UnitTestElementState.Pending;
}
this._cache.AddContext(type, context);
return(context);
}
private static void ProcessCSharpDeclaration(
[NotNull] IDeclaration declaration,
[NotNull] CodeStructureElement parentElement,
[NotNull] CSharpCodeStructureProcessingState state
)
{
switch (declaration)
{
case IClassLikeDeclaration classLikeDeclaration: {
var codeStructureClass = new T4CSharpCodeStructureDeclaredElement(parentElement, declaration, state);
if (classLikeDeclaration.Body != null)
{
ProcessCSharpChildren(classLikeDeclaration.Body, codeStructureClass, state);
}
return;
}
case ICSharpNamespaceDeclaration namespaceDeclaration: {
var structureNamespace = new T4CSharpCodeStructureNamespace(parentElement, declaration, state);
if (namespaceDeclaration.Body != null)
{
ProcessCSharpChildren(namespaceDeclaration.Body, structureNamespace, state);
}
return;
}
case IAccessorDeclaration _:
return;
case IEnumDeclaration enumDeclaration: {
var codeStructureElement = new T4CSharpCodeStructureDeclaredElement(parentElement, declaration, state)
{
InitiallyExpanded = false
};
ProcessCSharpChildren(enumDeclaration.EnumBody, codeStructureElement, state);
return;
}
default: {
var codeStructureElement2 = new T4CSharpCodeStructureDeclaredElement(parentElement, declaration, state);
ProcessCSharpChildren(declaration, codeStructureElement2, state);
break;
}
}
}
public override IDeclaredElement Analyze(IDeclaration element, IHighlightingConsumer consumer, DaemonProcessKind kind)
{
if (!(element is IFieldDeclaration field))
{
return(null);
}
var declaredElement = field.DeclaredElement;
if (declaredElement == null)
{
return(null);
}
bool isSerializedField = myUnityApi.IsSerialisedField(declaredElement);
if (isSerializedField)
{
const string displayText = "Serializable";
const string baseTooltip = "This field is initialized from Inspector";
if (myUnityApi.IsDescendantOfMonoBehaviour(declaredElement.GetContainingType()))
{
AddMonoBehaviourHighlighting(consumer, field, displayText, baseTooltip, kind);
return(declaredElement);
}
else if (myUnityApi.IsDescendantOfScriptableObject(declaredElement.GetContainingType()))
{
AddScriptableObjectHighlighting(consumer, field, displayText, baseTooltip, kind);
return(declaredElement);
}
else if (myUnityApi.IsInjectedField(declaredElement))
{
AddECSHighlighting(consumer, field, displayText, "This field is injected by Unity", kind);
return(declaredElement);
}
else
{
AddSerializableHighlighting(consumer, field, displayText, "This field is serialized by Unity", kind);
}
return(null);
}
return(null);
}
/// <summary>
/// Finds a declaration (excluding methods) with the specified name
/// </summary>
/// <param name="name">The name of the declaration to search for.</param>
/// <returns>The declaration with the specified name or null if not found.</returns>
public IDeclaration GetDeclaration(string name)
{
// Project
if (Project == null)
{
return(null);
}
IDeclaration superGlobalDeclaration = Project.GetDeclaration(name);
if (superGlobalDeclaration != null)
{
return(superGlobalDeclaration);
}
// Sprite
if (CurrentSprite == null)
{
return(null);
}
ITypedDeclaration globalDeclaration = CurrentSprite.GetDeclaration(name);
if (globalDeclaration != null)
{
return(globalDeclaration);
}
// Methods
if (CurrentScope == null)
{
return(null);
}
// Method params
ParamDeclaration methodParam = (CurrentScope.Method as MethodDeclaration)?.FindParam(name);
if (methodParam != null)
{
return(methodParam);
}
// Scoped variables
return(CurrentScope.Search(name));
}
private bool isDeclMatch(IDeclaration declaration)
{
if (declaration is IAccessorDeclaration)
{
return(false);
}
if (declaration.DeclaredElement != null)
{
DeclaredElementType type = declaration.DeclaredElement.GetElementType();
return(_declaration == Declaration.Any ||
_declMap.ContainsKey(type) && _declMap[type] == _declaration);
}
else
{
return(false);
}
}
protected virtual string GetConceptIdentifier(IDeclaration decl)
{
string name = null;
if (options.NameHandler.HandlesName(decl))
{
name = options.NameHandler.HandleName(decl);
}
else
{
name = decl.Name;
}
if (this.IsKeyword(name))
{
name = EscapeIdentifier(name);
}
return(name);
}
private void AddGutterMark(IDeclaration declaration, UnityEventFunction eventFunction,
IHighlightingConsumer consumer)
{
var tooltip = "Unity event function";
if (!string.IsNullOrEmpty(eventFunction.Description))
{
tooltip += Environment.NewLine + Environment.NewLine + eventFunction.Description;
}
if (eventFunction.Coroutine)
{
tooltip += Environment.NewLine + "This function can be a coroutine.";
}
var highlighting = new UnityGutterMarkInfo(declaration, tooltip);
consumer.AddHighlighting(highlighting);
}
public override void ResolveNames(LexicalScope ls)
{
if (ls != null)
{
var result = ls.Resolve(Identifier.Name);
if (result == null)
{
throw new ApplicationException($"Error: Undeclared identifier {Identifier.Name}");
}
else
{
Declaration = result;
type = Declaration.GetDeclarationType();
}
}
//ls.SymbolTable.Add(GetName(), this);
}
public override IType checkStaticMember(Context context, String name)
{
IDeclaration decl = context.getRegisteredDeclaration <IDeclaration>(GetTypeName());
if (decl == null)
{
throw new SyntaxError("Not a category:" + GetTypeName());
}
if (decl is EnumeratedCategoryDeclaration || decl is EnumeratedNativeDeclaration)
{
return(decl.GetIType(context).checkStaticMember(context, name));
}
if (decl is SingletonCategoryDeclaration)
{
return(checkAttribute(context, (SingletonCategoryDeclaration)decl, name));
}
throw new SyntaxError("No attribute:" + name + " in category:" + GetTypeName());
}
public override IValue getStaticMemberValue(Context context, String name)
{
IDeclaration decl = getDeclaration(context);
if (decl is EnumeratedCategoryDeclaration || decl is EnumeratedNativeDeclaration)
{
return(decl.GetIType(context).getStaticMemberValue(context, name));
}
else if (decl is SingletonCategoryDeclaration)
{
ConcreteInstance singleton = context.loadSingleton(this);
return(singleton.GetMemberValue(context, name, false));
}
else
{
return(base.getStaticMemberValue(context, name));
}
}
public void enterMethod(Context context, IDeclaration method)
{
terminateIfRequested();
stack.Push(new StackFrame(context, method.GetName(), method));
if (stack.Count > 0 && stack.Count <= stepDepth)
{
suspend(SuspendReason.STEPPING, context, method);
}
else if (method.Breakpoint)
{
suspend(SuspendReason.BREAKPOINT, context, method);
}
else
{
suspendIfRequested(context, method);
}
terminateIfRequested();
}
private void AddGutterMark(IDeclaration declaration, UnityEventFunction eventFunction,
IHighlightingConsumer consumer)
{
var documentRange = declaration.GetNameDocumentRange();
var tooltip = "Unity event function";
if (!string.IsNullOrEmpty(eventFunction.Description))
{
tooltip += Environment.NewLine + Environment.NewLine + eventFunction.Description;
}
if (eventFunction.Coroutine)
{
tooltip += Environment.NewLine + "This function can be a coroutine.";
}
var highlighting = new UnityMarkOnGutter(Api, declaration, documentRange, tooltip);
consumer.AddHighlighting(highlighting, documentRange);
}
private static void ProcessMemberDeclarations(IDeclaration declaration, OrderingOptions options)
{
bool propertyAccessorsMustFollowOrder = options.SA1212PropertyAccessorsMustFollowOrder;
bool eventAccessorsMustFollowOrder = options.SA1213EventAccessorsMustFollowOrder;
if (declaration is IIndexerDeclaration && propertyAccessorsMustFollowOrder)
{
CheckAccessorOrder(declaration as IIndexerDeclaration);
}
else if (declaration is IPropertyDeclaration && propertyAccessorsMustFollowOrder)
{
CheckAccessorOrder(declaration as IPropertyDeclaration);
}
else if (declaration is IEventDeclaration && eventAccessorsMustFollowOrder)
{
CheckAccessorOrder(declaration as IEventDeclaration);
}
}
public void Check(IDeclaration declaration, INamingPolicyProvider namingPolicyProvider, out bool isFinalResult, out NamingConsistencyCheckResult result)
{
var methodDeclaration = declaration as IMethodDeclaration;
if (methodDeclaration != null && MonoBehaviourUtil.IsEventHandler(methodDeclaration.DeclaredName))
{
var containingTypeElement = methodDeclaration.GetContainingTypeDeclaration().DeclaredElement;
if (containingTypeElement != null && MonoBehaviourUtil.IsMonoBehaviourType(containingTypeElement, methodDeclaration.GetPsiModule()))
{
result = NamingConsistencyCheckResult.OK;
isFinalResult = true;
return;
}
}
result = null;
isFinalResult = false;
}
private static void ProcessCSharpDeclaration([NotNull] IDeclaration declaration, [NotNull] CodeStructureElement parentElement,
[NotNull] CSharpCodeStructureProcessingState state)
{
var classLikeDeclaration = declaration as IClassLikeDeclaration;
if (classLikeDeclaration != null)
{
var codeStructureClass = new T4CSharpCodeStructureDeclaredElement(parentElement, declaration, state);
if (classLikeDeclaration.Body != null)
{
ProcessCSharpChildren(classLikeDeclaration.Body, codeStructureClass, state);
}
return;
}
var namespaceDeclaration = declaration as ICSharpNamespaceDeclaration;
if (namespaceDeclaration != null)
{
var structureNamespace = new T4CSharpCodeStructureNamespace(parentElement, declaration, state);
if (namespaceDeclaration.Body != null)
{
ProcessCSharpChildren(namespaceDeclaration.Body, structureNamespace, state);
}
return;
}
if (declaration is IAccessorDeclaration)
{
return;
}
var codeStructureElement = new T4CSharpCodeStructureDeclaredElement(parentElement, declaration, state);
var enumDeclaration = declaration as IEnumDeclaration;
if (enumDeclaration != null)
{
codeStructureElement.InitiallyExpanded = false;
ProcessCSharpChildren(enumDeclaration.EnumBody, codeStructureElement, state);
return;
}
ProcessCSharpChildren(declaration, codeStructureElement, state);
}
public void ExecuteTemplate()
{
IDeclaration newDeclaration = this.myDeclaration;
newDeclaration.AssertIsValid();
ISolution solution = newDeclaration.GetPsiModule().GetSolution();
Debug.Assert(Shell.Instance.Invocator != null, "Shell.Instance.Invocator != null");
Shell.Instance.Invocator.Dispatcher.AssertAccess();
solution.GetComponent <SolutionDocumentTransactionManager>().AssertNotUnderTransaction();
IFile file = this.myAnchor.GetContainingFile();
Assertion.Assert(file != null, "fileFullName!= null");
var item = file.GetSourceFile().ToProjectFile();
var infos = GetFieldInfos(newDeclaration, this.myHolders);
var textControl = EditorManager.GetInstance(solution).OpenProjectFile(item, true);
if (textControl == null)
{
if (Shell.Instance.IsInInternalMode || Shell.Instance.IsTestShell)
{
Logger.Fail("textControl != null");
}
return;
}
if (infos.Length > 0)
{
HotspotSession hotspotSession = LiveTemplatesManager.Instance.CreateHotspotSessionAtopExistingText(
solution,
TextRange.InvalidRange,
textControl,
LiveTemplatesManager.EscapeAction.LeaveTextAndCaret,
infos);
hotspotSession.Execute();
}
Shell.Instance.GetComponent <NTriplesIntentionResultBehavior>().OnHotspotSessionExecutionStarted(this, textControl);
}
public FunctionDecl(Cursor c, ISymbolTable table)
: base(c, table)
{
Debug.Assert(c.Kind == CursorKind.FunctionDecl);
if (c.SemanticParentCurosr.Kind == CursorKind.Namespace)
{
_parent = table.FindNamespaceDeclaration(c.SemanticParentCurosr.Usr);
Debug.Assert(_parent != null);
}
else if (c.SemanticParentCurosr.Kind == CursorKind.TranslationUnit ||
c.SemanticParentCurosr.Kind == CursorKind.UnexposedDecl)
{
_parent = null;
}
else
{
Debug.Assert(false);
}
}
public T4CSharpCodeStructureDeclaredElement(CodeStructureElement parentElement, IDeclaration declaration, CSharpCodeStructureProcessingState state)
: base(parentElement, declaration) {
IDeclaredElement declaredElement = declaration.DeclaredElement;
InitiallyExpanded = true;
if (declaredElement != null && state.Options.BuildInheritanceInformation) {
_inheritanceInformation = InheritanceInformation.FromDeclaredElement(declaredElement);
if (_inheritanceInformation != null) {
var structureDeclaredElement = parentElement as T4CSharpCodeStructureDeclaredElement;
if (structureDeclaredElement != null)
structureDeclaredElement.ChildrenWithInheritance = true;
}
}
_parentRegion = state.Regions.TryPeek();
if (declaredElement != null)
_aspects = new T4CSharpCodeStructureAspects(this, declaration);
}
public void ShouldBeAbleToBuildAList()
{
IDeclaration <MyClass> declaration = MockRepository.GenerateMock <IDeclaration <MyClass> >();
var builder = new ListBuilder <MyClass>(listSize, propertyNamer, reflectionUtil, new BuilderSettings());
using (mocks.Record())
{
reflectionUtil.Stub(x => x.RequiresConstructorArgs(typeof(MyClass))).Return(false).Repeat.Any();
reflectionUtil.Expect(x => x.CreateInstanceOf <MyClass>()).Return(myClass).Repeat.Any();
declaration.Expect(x => x.Construct());
declaration.Expect(x => x.AddToMaster(Arg <MyClass[]> .Is.TypeOf));
propertyNamer.Expect(x => x.SetValuesOfAllIn(Arg <IList <MyClass> > .Is.TypeOf));
declaration.Expect(x => x.CallFunctions(Arg <IList <MyClass> > .Is.TypeOf)).IgnoreArguments();
}
using (mocks.Playback())
builder.Build();
}
public static TreeNodeCollection <IFSharpAttribute> GetAttributes([NotNull] this IDeclaration declaration)
{
switch (declaration)
{
case IFSharpTypeDeclaration typeDeclaration:
return(typeDeclaration.Attributes);
case IMemberDeclaration memberDeclarationm:
return(memberDeclarationm.Attributes);
case ILet letBinding:
return(letBinding.Attributes);
case IModuleLikeDeclaration moduleLikeDeclaration:
return(moduleLikeDeclaration.Attributes);
default: return(TreeNodeCollection <IFSharpAttribute> .Empty);
}
}
public EnumDecl(Cursor c, ISymbolTable table)
: base(c, table)
{
Debug.Assert(c.Kind == CursorKind.EnumDecl);
if (c.SemanticParentCurosr.Kind == CursorKind.Namespace)
{
_parent = table.FindNamespaceDeclaration(c.SemanticParentCurosr.Usr);
Debug.Assert(_parent != null);
}
else if (CursorKinds.IsClassStructEtc(c.SemanticParentCurosr.Kind))
{
_parent = table.FindClassDeclaration(c.SemanticParentCurosr.Usr);
Debug.Assert(_parent != null);
}
else
{
CursorKind k = c.SemanticParentCurosr.Kind;
}
}
public static TreeNodeCollection <IAttribute> GetAttributes([NotNull] this IDeclaration declaration)
{
switch (declaration)
{
case IFSharpTypeOldDeclaration typeDeclaration:
return(typeDeclaration.Attributes);
case IMemberSignatureOrDeclaration memberDeclaration:
return(memberDeclaration.Attributes);
case IFSharpPattern fsPattern:
return(fsPattern.Attributes);
case IDeclaredModuleDeclaration moduleDeclaration:
return(moduleDeclaration.Attributes);
default: return(TreeNodeCollection <IAttribute> .Empty);
}
}
private void DefineType(string packageName, AccelTypeInfo declaringType, TypeBuilder declaringTypeBuilder, StructDeclaration def, Dictionary <string, AccelTypeInfo> result)
{
string name = def.Name;
string fullName = def.IsNested ? $"{declaringType.FullName}+{def.Name}" : $"{packageName}.{def.Name}";
Dictionary <string, AccelFieldInfo> fields = new Dictionary <string, AccelFieldInfo>(def.Declarations.Declarations.Length);
Type baseType = def.IsRef ? typeof(object) : typeof(ValueType);
TypeBuilder builder = RuntimeInjector.DefinePublicType(def.IsNested ? name : fullName, def.IsFinal, declaringTypeBuilder, baseType, Type.EmptyTypes);
AccelTypeInfo info = new AccelTypeInfo(name, fullName, def.Doc, TypeVisibility.Public, def.IsFinal, def.IsRef, def.IsNested, def.IsFieldIndexContinuous, (int)def.Size, declaringType, fields);
for (int i = 0; i < def.Declarations.Declarations.Length; i++)
{
IDeclaration declaration = def.Declarations.Declarations[i];
switch (declaration)
{
case FieldDeclaration fieldDeclaration:
Type fieldType = GetType(fieldDeclaration.Type);
Type realType = fieldDeclaration.RealType == null ? null : GetType(fieldDeclaration.RealType);
builder.DefineField(fieldDeclaration.Name, fieldType, FieldAttributes.Public);
AccelFieldInfo fieldInfo = new AccelFieldInfo(fieldDeclaration.Name, fieldDeclaration.Doc, (int)fieldDeclaration.Index, fieldDeclaration.IsObsolete, fieldDeclaration.IsNeverNull, info, fieldType, realType);
fields.Add(fieldDeclaration.Name, fieldInfo);
break;
case StructDeclaration structDeclaration:
DefineType(packageName, info, builder, structDeclaration, result);
break;
default:
continue;
}
}
Type type = builder.CreateType();
info.TypeHandle = type.TypeHandle;
foreach (FieldInfo field in type.GetFields())
{
fields[field.Name].FieldHandle = field.FieldHandle;
}
result.Add(fullName, info);
}
public void AddDeclaration(IDeclaration declaration)
{
List<IDeclaration> declarations;
if (declaration.Name != null)
{
string name = declaration.Name.Text;
if (string.IsNullOrEmpty(name))
return;
if (!Declarations.TryGetValue(name, out declarations))
{
declarations = new List<IDeclaration>();
Declarations.Add(name, declarations);
}
}
else
{
declarations = new List<IDeclaration>();
}
var genericsDeclarator = declaration as IGenerics;
if (genericsDeclarator != null)
{
for (int i = 0; i < genericsDeclarator.GenericParameters.Count; i++)
{
var genericArgument = genericsDeclarator.GenericParameters[i];
var genericName = genericArgument.Name.Text;
List<GenericDeclaration> generics;
if (!Generics.TryGetValue(genericName, out generics))
{
generics = new List<GenericDeclaration>();
Generics.Add(genericName, generics);
}
generics.Add(new GenericDeclaration(genericArgument.Name, genericsDeclarator, i, false) { Span = genericArgument.Span });
}
}
if (!declarations.Contains(declaration))
declarations.Add(declaration);
}
/// <summary>Checks the declaration documentation.</summary>
/// <param name="declaration">The declaration.</param>
/// <param name="options">The options.</param>
private void Annotate(IDeclaration declaration, ValueAnalysisOptions options)
{
if (!options.AnnotateWithValueAnalysisAttributes && !options.InsertAssertStatements)
{
return;
}
var typeMemberDeclaration = declaration as ITypeMemberDeclaration;
if (typeMemberDeclaration == null)
{
return;
}
var refactoring = new ValueAnalysisRefactoring(typeMemberDeclaration);
refactoring.AnnotateWithValueAnalysisAttributes = options.AnnotateWithValueAnalysisAttributes;
refactoring.InsertAssertStatements = options.InsertAssertStatements;
refactoring.TreatAllMembersAsNonPublic = options.TreatAllMembersAsNonPublic;
refactoring.Execute();
}
/// <summary>
/// Updates the summary to include all <c>typeparam</c> and remove any extra ones and in the correct order.
/// </summary>
/// <param name="declaration">
/// The <see cref="ITypeDeclaration"/> to check and fix.
/// </param>
public void InsertMissingTypeParamElement(IDeclaration declaration)
{
ITypeParametersOwner declaredElement = declaration.DeclaredElement as ITypeParametersOwner;
if (declaredElement == null)
{
return;
}
DeclarationHeader declarationHeader = new DeclarationHeader(declaration);
if (declarationHeader.IsMissing || declarationHeader.IsInherited)
{
return;
}
XmlNode xmlNode = declarationHeader.XmlNode;
Hashtable ht = new Hashtable();
foreach (ITypeParameter parameter in declaredElement.TypeParameters)
{
ht.Add(parameter.ShortName, null);
if (declarationHeader.ContainsTypeParameter(parameter.ShortName))
{
continue;
}
XmlNode parameterNode = CreateTypeParamNode(xmlNode, parameter.ShortName);
XmlNodeList paramNodeList = xmlNode.SelectNodes("//typeparam");
if (paramNodeList != null)
{
XmlNode c = paramNodeList.Count == 0 ? declarationHeader.SummaryXmlNode : paramNodeList.Item(paramNodeList.Count - 1);
xmlNode.InsertAfter(parameterNode, c);
}
}
RemoveTypeParamsNotRequired(xmlNode, ht);
ReorderTypeParams(xmlNode, declaredElement.TypeParameters);
declarationHeader.Update();
}
/// <summary>
/// Takes the XmlNode and creates a formatted StringBuilder of it all formatted lovely.
/// </summary>
/// <param name="xml">
/// The xml to use.
/// </param>
/// <param name="declaration">
/// The declaration we start with.
/// </param>
/// <returns>
/// A String all formatted.
/// </returns>
private static string LayoutDocumentationHeader(XmlNode xml, IDeclaration declaration)
{
StringBuilder pattern = new StringBuilder();
StringWriter writer = new StringWriter(pattern);
bool writtenNewLine = true;
IContextBoundSettingsStore settingsStore = PsiSourceFileExtensions.GetSettingsStore(null, declaration.GetSolution());
bool useSingleLineDeclarationComments = settingsStore.GetValue((StyleCopOptionsSettingsKey key) => key.UseSingleLineDeclarationComments);
LayoutDocumentationXml(xml, writer, ref writtenNewLine, useSingleLineDeclarationComments);
if (pattern.ToString().EndsWith(Environment.NewLine))
{
pattern.Remove(pattern.Length - Environment.NewLine.Length, Environment.NewLine.Length);
}
if (pattern.ToString().StartsWith(Environment.NewLine))
{
pattern.Remove(0, Environment.NewLine.Length);
}
return pattern.ToString().Trim();
}
/// <summary>
/// Insert a missing parameter element to the comment.
/// </summary>
/// <param name="declaration">
/// The <see cref="IDeclaration"/> to check and fix.
/// </param>
public void InsertMissingParamElement(IDeclaration declaration)
{
Param.RequireNotNull(declaration, "declaration");
IParametersOwnerDeclaration parametersOwnerDeclaration = declaration as IParametersOwnerDeclaration;
if (parametersOwnerDeclaration == null)
{
return;
}
DeclarationHeader declarationHeader = new DeclarationHeader(declaration);
if (declarationHeader.IsMissing || declarationHeader.IsInherited)
{
return;
}
XmlNode xmlNode = declarationHeader.XmlNode;
Hashtable ht = new Hashtable();
IList<IParameterDeclaration> parameters = parametersOwnerDeclaration.ParameterDeclarations;
if (parameters != null)
{
foreach (IParameterDeclaration parameter in parameters)
{
ht.Add(parameter.DeclaredName, null);
if (declarationHeader.ContainsParameter(parameter.DeclaredName))
{
continue;
}
XmlNodeList paramNodeList = xmlNode.SelectNodes("//param");
if (paramNodeList != null)
{
XmlNode c = paramNodeList.Count == 0 ? declarationHeader.SummaryXmlNode : paramNodeList.Item(paramNodeList.Count - 1);
XmlNode parameterNode = CreateParamNode(xmlNode, parameter);
xmlNode.InsertAfter(parameterNode, c);
}
}
}
RemoveParamsNotRequired(xmlNode, ht);
ReorderParams(xmlNode, parameters);
declarationHeader.Update();
}
/// <summary>
/// Returns the xml for the given declaration or null.
/// </summary>
/// <param name="declaration">
/// The declaration to get the docs for.
/// </param>
/// <returns>
/// An XmlNode of the docs.
/// </returns>
private static XmlNode GetXmlNodeForDeclaration(IDeclaration declaration)
{
IDeclaration declarationTreeNode = declaration;
ITreeNode treeNode = declarationTreeNode is IMultipleDeclarationMember ? declarationTreeNode.Parent.FirstChild : declarationTreeNode.FirstChild;
XmlNode node;
StringBuilder text = new StringBuilder();
text.AppendLine("<member>");
for (ITreeNode child = treeNode.FirstChild; child != null; child = child.NextSibling)
{
if (child.IsNewLine())
{
text.AppendLine(string.Empty);
continue;
}
IDocCommentNode docCommentNode = child as IDocCommentNode;
if (docCommentNode != null)
{
text.Append(docCommentNode.CommentText);
}
}
text.AppendLine("</member>");
try
{
XmlDocument xmlDoc = new XmlDocument { PreserveWhitespace = true };
xmlDoc.LoadXml(text.ToString());
node = xmlDoc.SelectSingleNode("member");
}
catch (XmlException)
{
return null;
}
return node;
}
/// <summary>
/// Formats a summary element.
/// </summary>
/// <param name="declaration">
/// The <see cref="IDeclaration"/> to format the text for.
/// </param>
public void FormatSummaryElement(IDeclaration declaration)
{
DeclarationHeader declarationHeader = new DeclarationHeader(declaration);
if (declarationHeader.IsMissing || declarationHeader.IsInherited || declarationHeader.HasEmptySummary || !declarationHeader.HasSummary)
{
return;
}
declarationHeader.Update();
}
/// <summary>
/// Ensures the declaration passed has its comments beginning with a capital letter.
/// </summary>
/// <param name="declaration">
/// The destructor <see cref="IDeclaration"/>.
/// </param>
public void EnsureDocumentationTextIsUppercase(IDeclaration declaration)
{
IContextBoundSettingsStore settingsStore = PsiSourceFileExtensions.GetSettingsStore(null, declaration.GetSolution());
if (!settingsStore.GetValue((StyleCopOptionsSettingsKey key) => key.InsertTextIntoDocumentation))
{
return;
}
DeclarationHeader declarationHeader = new DeclarationHeader(declaration);
if (declarationHeader.IsMissing || declarationHeader.IsInherited)
{
return;
}
this.SwapToUpper(declarationHeader.XmlNode);
declarationHeader.Update();
}
/// <summary>
/// Ensures the declaration passed has no blank lines unless inside code elements.
/// </summary>
/// <param name="declaration">
/// The destructor <see cref="IDeclaration"/>.
/// </param>
public void EnsureDocumentationHasNoBlankLines(IDeclaration declaration)
{
DeclarationHeader declarationHeader = new DeclarationHeader(declaration);
if (declarationHeader.IsMissing || declarationHeader.IsInherited)
{
return;
}
this.RemoveBlankLines(declarationHeader.XmlNode);
declarationHeader.Update();
}
/// <summary>
/// Initializes a new instance of the DeclarationHeader class.
/// </summary>
/// <param name="declaration">
/// The declaration to use.
/// </param>
public DeclarationHeader(IDeclaration declaration)
{
this.Init(declaration);
}
/// <summary>
/// Initializes this type.
/// </summary>
/// <param name="declaration">
/// The declaration.
/// </param>
private void Init(IDeclaration declaration)
{
if (declaration == null)
{
this.IsMissing = true;
return;
}
this.Declaration = declaration;
this.DocCommentBlockNode = Utils.GetDocCommentBlockNodeForDeclaration(declaration);
if (this.DocCommentBlockNode == null)
{
this.IsMissing = true;
}
else
{
this.XmlNode = GetXmlNodeForDeclaration(declaration);
if (this.XmlNode == null)
{
this.IsMissing = true;
}
else
{
if (this.XmlNode.SelectSingleNode("//inheritdoc") != null)
{
this.IsInherited = true;
}
XmlNode node = this.XmlNode.SelectSingleNode("//summary");
if (node != null)
{
this.HasSummary = true;
this.SummaryXmlNode = node;
}
node = this.XmlNode.SelectSingleNode("//returns");
if (node != null)
{
this.HasReturns = true;
this.ReturnsXmlNode = node;
}
node = this.XmlNode.SelectSingleNode("//value");
if (node != null)
{
this.HasValue = true;
this.ValueXmlNode = node;
}
}
}
}
/// <summary>
/// Inserts a missing summary element.
/// </summary>
/// <param name="declaration">
/// The <see cref="IDeclaration"/> to get comment from.
/// </param>
/// <returns>
/// True if the element was inserted.
/// </returns>
public bool InsertMissingSummaryElement(IDeclaration declaration)
{
bool returnValue = false;
DeclarationHeader declarationHeader = new DeclarationHeader(declaration);
if (declarationHeader.IsMissing || declarationHeader.IsInherited)
{
return false;
}
string summaryText = string.Empty;
IContextBoundSettingsStore settingsStore = PsiSourceFileExtensions.GetSettingsStore(null, declaration.GetSolution());
if (settingsStore.GetValue((StyleCopOptionsSettingsKey key) => key.InsertTextIntoDocumentation))
{
string text;
if (declaration is IInterfaceDeclaration)
{
text = declaration.DeclaredName.Substring(1) + " interface";
}
else
{
text = Utils.ConvertTextToSentence(declaration.DeclaredName).ToLower();
}
summaryText = string.Format("The {0}.", text);
}
summaryText = Utils.UpdateTextWithToDoPrefixIfRequired(summaryText, settingsStore);
XmlNode summaryXmlNode = declarationHeader.SummaryXmlNode;
if (declarationHeader.HasSummary)
{
if (declarationHeader.HasEmptySummary)
{
summaryXmlNode.InnerText = summaryText;
declarationHeader.Update();
returnValue = true;
}
}
else
{
XmlNode newChild = CreateNode(declarationHeader.XmlNode, "summary");
newChild.InnerText = summaryText;
declarationHeader.XmlNode.InsertBefore(newChild, declarationHeader.XmlNode.FirstChild);
declarationHeader.Update();
returnValue = true;
}
return returnValue;
}
/// <summary>
/// Checks declaration comment blocks.
/// </summary>
/// <param name="file">
/// The <see cref="ICSharpFile"/> to use.
/// </param>
/// <param name="declaration">
/// The <see cref="IDeclaration"/> to check.
/// </param>
/// <param name="options">
/// <see cref="OrderingOptions"/>Current options that we can reference.
/// </param>
public void CheckDeclarationDocumentation(ICSharpFile file, IDeclaration declaration, DocumentationOptions options)
{
Param.RequireNotNull(file, "file");
Param.RequireNotNull(declaration, "declaration");
Param.Ignore(options);
bool insertMissingElementDocOption = true;
bool documentationTextMustBeginWithACapitalLetter = true;
bool documentationTextMustEndWithAPeriod = true;
bool elementDocumentationMustHaveSummary = true;
bool constructorSummaryDocBeginsWithStandardText = true;
bool destructorSummaryDocBeginsWithStandardText = true;
bool propertyDocumentationMustHaveValueDocumented = true;
bool insertMissingParamTagOption = true;
bool genericTypeParametersMustBeDocumented = true;
if (options != null)
{
insertMissingElementDocOption = options.SA1600ElementsMustBeDocumented;
documentationTextMustBeginWithACapitalLetter = options.SA1628DocumentationTextMustBeginWithACapitalLetter;
documentationTextMustEndWithAPeriod = options.SA1629DocumentationTextMustEndWithAPeriod;
elementDocumentationMustHaveSummary = options.SA1604ElementDocumentationMustHaveSummary;
constructorSummaryDocBeginsWithStandardText = options.SA1642ConstructorSummaryDocumentationMustBeginWithStandardText;
destructorSummaryDocBeginsWithStandardText = options.SA1643DestructorSummaryDocumentationMustBeginWithStandardText;
propertyDocumentationMustHaveValueDocumented = options.SA1609PropertyDocumentationMustHaveValue;
insertMissingParamTagOption = options.SA1611ElementParametersMustBeDocumented;
genericTypeParametersMustBeDocumented = options.SA1618GenericTypeParametersMustBeDocumented;
}
DeclarationHeader declarationHeader = new DeclarationHeader(declaration);
bool formatSummary = false;
if (insertMissingElementDocOption && !Utils.IsRuleSuppressed(declaration, StyleCopRules.SA1600) && declarationHeader.IsMissing)
{
formatSummary = this.InsertMissingDeclarationHeader(file, declaration);
}
if (elementDocumentationMustHaveSummary && !Utils.IsRuleSuppressed(declaration, StyleCopRules.SA1604) && !declarationHeader.HasSummary)
{
formatSummary = formatSummary | this.InsertMissingSummaryElement(declaration);
}
if (formatSummary)
{
this.FormatSummaryElement(declaration);
}
if (declaration is IConstructorDeclaration)
{
if (insertMissingParamTagOption && !Utils.IsRuleSuppressed(declaration, StyleCopRules.SA1611))
{
IConstructorDeclaration constructorDeclaration = declaration as IConstructorDeclaration;
if (constructorDeclaration.ParameterDeclarations.Count > 0)
{
this.InsertMissingParamElement(constructorDeclaration);
}
}
if (constructorSummaryDocBeginsWithStandardText && !Utils.IsRuleSuppressed(declaration, StyleCopRules.SA1642))
{
this.EnsureConstructorSummaryDocBeginsWithStandardText(declaration as IConstructorDeclaration);
}
}
DocumentationRulesConfiguration docConfig = this.GetDocumentationRulesConfig(file);
// However it can be on/off depending on the file so we'd have to cache it per file
bool ruleIsEnabled = docConfig.GetStyleCopRuleEnabled("DocumentationTextMustBeginWithACapitalLetter");
if (documentationTextMustBeginWithACapitalLetter && ruleIsEnabled && !Utils.IsRuleSuppressed(declaration, StyleCopRules.SA1628))
{
this.EnsureDocumentationTextIsUppercase(declaration);
}
ruleIsEnabled = docConfig.GetStyleCopRuleEnabled("DocumentationTextMustEndWithAPeriod");
if (documentationTextMustEndWithAPeriod && ruleIsEnabled && !Utils.IsRuleSuppressed(declaration, StyleCopRules.SA1629))
{
this.EnsureDocumentationTextEndsWithAPeriod(declaration);
}
if (declaration is IDestructorDeclaration)
{
if (destructorSummaryDocBeginsWithStandardText && !Utils.IsRuleSuppressed(declaration, StyleCopRules.SA1643))
{
this.EnsureDestructorSummaryDocBeginsWithStandardText(declaration as IDestructorDeclaration);
}
}
if (declaration is IMethodDeclaration || declaration is IIndexerDeclaration)
{
this.CheckMethodAndIndexerDeclarationDocumentation(declaration as IParametersOwnerDeclaration, options);
}
if (declaration is IPropertyDeclaration)
{
ruleIsEnabled = docConfig.GetStyleCopRuleEnabled("PropertyDocumentationMustHaveValue");
if (propertyDocumentationMustHaveValueDocumented && ruleIsEnabled && !Utils.IsRuleSuppressed(declaration, StyleCopRules.SA1609))
{
this.InsertValueElement(declaration as IPropertyDeclaration);
}
}
if (declaration is ITypeParametersOwner && (genericTypeParametersMustBeDocumented && !Utils.IsRuleSuppressed(declaration, StyleCopRules.SA1618)))
{
this.InsertMissingTypeParamElement(declaration);
}
}
/// <summary>
/// Insert a summary element if missing.
/// </summary>
/// <param name="file">
/// The <see cref="ICSharpFile"/> to use.
/// </param>
/// <param name="declaration">
/// The <see cref="ITypeDeclaration"/> to check and fix.
/// </param>
/// <returns>
/// True if it inserted a missing header.
/// </returns>
public bool InsertMissingDeclarationHeader(ICSharpFile file, IDeclaration declaration)
{
StyleCopTrace.In(file, declaration);
Param.RequireNotNull(file, "file");
Param.RequireNotNull(declaration, "declaration");
Debug.Assert(declaration.DeclaredElement != null, "declaration.DeclaredElement != null");
bool returnValue = false;
DocumentationRulesConfiguration docConfig = this.GetDocumentationRulesConfig(file);
bool isIFieldDeclaration = declaration is IFieldDeclaration;
AccessRights accessRights = ((IModifiersOwnerDeclaration)declaration).GetAccessRights();
DeclaredElementType elementType = declaration.DeclaredElement.GetElementType();
if ((!isIFieldDeclaration || docConfig.RequireFields) && (accessRights != AccessRights.PRIVATE || !docConfig.IgnorePrivates)
&& (accessRights != AccessRights.INTERNAL || !docConfig.IgnoreInternals))
{
DeclarationHeader.CreateNewHeader(declaration, docConfig);
returnValue = true;
}
return StyleCopTrace.Out(returnValue);
}
/// <summary>
/// Builds a xml doc header from the string passed in all set out correctly.
/// </summary>
/// <param name="header">
/// The text to use to build the header.
/// </param>
/// <param name="declaration">
/// The declaration we start with.
/// </param>
/// <returns>
/// A String of the correctly formatted header.
/// </returns>
private static string LayoutDocumentationHeader(string header, IDeclaration declaration)
{
StringBuilder text = new StringBuilder();
text.AppendLine("<member>");
text.AppendLine(header);
text.AppendLine("</member>");
XmlDocument xmlDoc = new XmlDocument { PreserveWhitespace = true };
xmlDoc.LoadXml(text.ToString());
return LayoutDocumentationHeader(xmlDoc.SelectSingleNode("member"), declaration);
}
