コード例 #1
0
        /// <summary>
        /// Extracts the method contracts. Does not visit property accessors.
        /// </summary>
        public override void Visit(IMethodDefinition methodDefinition)
        {
            Contract.Assert(methodDefinition != null);

            if (CCDocContractHelper.IsCompilerGenerated(this.host, methodDefinition))
            {
                return; //Don't continue traverser
            }
            if (MethodHelper.IsGetter(methodDefinition) || MethodHelper.IsSetter(methodDefinition))
            {
                return;
            }

            string methodId = MemberHelper.GetMemberSignature(methodDefinition, NameFormattingOptions.DocumentationId);

            docTracker.WriteLine(methodId);

            bool isPure = IsPure(methodDefinition);//TODO: Remove, this should be handled on the packager side.

            ContractPackager packager = new ContractPackager(host, docTracker);

            packager.PackageMethodContracts(methodDefinition, isPure);
            XContract[] contractArray;
            if (packager.TryGetContracts(out contractArray))
            {
                docTracker.AddMemberInfo(contractArray.Length, MemberKind.Method);
                contracts.Add(new KeyValuePair <string, XContract[]>(methodId, contractArray));
            }
            else
            {
                docTracker.AddMemberInfo(0, MemberKind.Method);
            }

            //base.TraverseChildren(methodDefinition);
        }
コード例 #2
0
 public override void TraverseChildren(ITypeDefinition typeDefinition)
 {
     if (CCDocContractHelper.IsCompilerGenerated(this.host, typeDefinition) || IsContractClass(typeDefinition))
     {
         return; //Don't continue traverser
     }
     base.TraverseChildren(typeDefinition);
 }
コード例 #3
0
            /// <summary>
            /// Attempts to package all contracts for a type. Does not include inherited contracts.
            /// </summary>
            public void PackageTypeContracts(ITypeDefinition type)
            {
                Contract.Requires(type != null);

                #region Package contracts from this implementation
                ITypeContract typeContract;
                if (CCDocContractHelper.TryGetTypeContract(this.host, type, out typeContract, docTracker))
                {
                    if (IteratorHelper.EnumerableIsNotEmpty <ITypeInvariant>(typeContract.Invariants))
                    {
                        PackageInvariants(typeContract.Invariants);
                    }
                }
                #endregion
            }
コード例 #4
0
            public void PackageMethodContracts(IMethodDefinition method, bool isPure)
            {
                Contract.Requires(method != null);

                #region Package purity
                if (isPure)
                {
                    PackageContract(new XPure(this.host, isPure, docTracker));
                }
                //Don't package anything if it isn't pure. (That way it is easyer to deal with on the Sandcastle side)
                #endregion
                #region Package contracts from this implementation
                IMethodContract thisContract;
                if (CCDocContractHelper.TryGetMethodContract(host, method, out thisContract, docTracker))
                {
                    PackageMethodContracts(thisContract, null, null);
                }
                #endregion
                #region Package contracts from base overrides
                if (!method.IsNewSlot) // REVIEW: Is there a better test?
                {
                    IMethodDefinition overriddenMethod = MemberHelper.GetImplicitlyOverriddenBaseClassMethod(method) as IMethodDefinition;
                    while (overriddenMethod != null && overriddenMethod != Dummy.Method)
                    {
                        IMethodContract /*?*/ overriddenContract;
                        if (CCDocContractHelper.TryGetMethodContract(host, overriddenMethod, out overriddenContract, docTracker))
                        {
                            SubstituteParameters sps         = new SubstituteParameters(this.host, method, overriddenMethod);
                            IMethodContract      newContract = sps.Rewrite(overriddenContract) as MethodContract;
                            var unspecializedMethod          = MethodHelper.Unspecialize(overriddenMethod);
                            var methodId = MemberHelper.GetMemberSignature(unspecializedMethod, NameFormattingOptions.DocumentationId);
                            var typeName = TypeHelper.GetTypeName(unspecializedMethod.ContainingType, NameFormattingOptions.OmitContainingNamespace | NameFormattingOptions.OmitContainingType);
                            PackageMethodContracts(newContract, methodId, typeName);
                        }
                        overriddenMethod = MemberHelper.GetImplicitlyOverriddenBaseClassMethod(overriddenMethod) as IMethodDefinition;
                    }
                }
                #endregion
                #region Package contracts from implicit interface implementations
                foreach (IMethodDefinition ifaceMethod in MemberHelper.GetImplicitlyImplementedInterfaceMethods(method))
                {
                    IMethodContract /*?*/ ifaceContract;
                    if (!CCDocContractHelper.TryGetMethodContract(host, ifaceMethod, out ifaceContract, docTracker))
                    {
                        continue;
                    }
                    SubstituteParameters sps         = new SubstituteParameters(this.host, method, ifaceMethod);
                    IMethodContract      newContract = sps.Rewrite(ifaceContract) as MethodContract;
                    var unspecializedMethod          = MethodHelper.Unspecialize(ifaceMethod);
                    var methodId = MemberHelper.GetMemberSignature(unspecializedMethod, NameFormattingOptions.DocumentationId);
                    var typeName = TypeHelper.GetTypeName(unspecializedMethod.ContainingType, NameFormattingOptions.OmitContainingNamespace | NameFormattingOptions.OmitContainingType);
                    PackageMethodContracts(newContract, methodId, typeName);
                }
                #endregion
                #region Package contracts from explicit interface implementations
                // REVIEW: Why does GetExplicitlyOverriddenMethods return IMethodReference when GetImplicitlyImplementedInterfaceMethods
                // returns IMethodDefinition?
                foreach (IMethodReference ifaceMethodRef in MemberHelper.GetExplicitlyOverriddenMethods(method))
                {
                    IMethodDefinition /*?*/ ifaceMethod = ifaceMethodRef.ResolvedMethod;
                    if (ifaceMethod == null)
                    {
                        continue;
                    }
                    IMethodContract /*?*/ ifaceContract;
                    if (!CCDocContractHelper.TryGetMethodContract(host, ifaceMethod, out ifaceContract, docTracker))
                    {
                        continue;
                    }
                    SubstituteParameters sps         = new SubstituteParameters(this.host, method, ifaceMethod);
                    IMethodContract      newContract = sps.Rewrite(ifaceContract) as MethodContract;
                    var unspecializedMethod          = MethodHelper.Unspecialize(ifaceMethod);
                    var methodId = MemberHelper.GetMemberSignature(unspecializedMethod, NameFormattingOptions.DocumentationId);
                    var typeName = TypeHelper.GetTypeName(unspecializedMethod.ContainingType, NameFormattingOptions.OmitContainingNamespace | NameFormattingOptions.OmitContainingType);
                    PackageMethodContracts(newContract, methodId, typeName);;
                }
                #endregion
            }