public static bool TryGetInterfaceMember(CSharpMember member, out CSharpMember interfaceMethod)
{
Contract.Requires(member != null);
Contract.Ensures(!Contract.Result <bool>() ||
Contract.ValueAtReturn(out interfaceMethod) != null);
interfaceMethod = null;
if (member.ExplicitInterfaceImplementation != null)
{
if (TryGetMemberWithSameSignatureFromType(member.ExplicitInterfaceImplementation, member, out interfaceMethod))
{
return(true);
}
}
if (member.ContainingType == null || member.ContainingType.BaseInterfaces == null)
{
return(false);
}
foreach (var i in member.ContainingType.BaseInterfaces)
{
if (i == null)
{
continue;
}
if (TryGetMemberWithSameSignatureFromType(i, member, out interfaceMethod))
{
return(true);
}
}
return(false);
}
public IllFormedSemanticModelException(string message, CSharpMember badMember) : base(message)
{
Contract.Requires(badMember != null);
BadMember = badMember;
Kind = CSharpKind.CSharpMember;
}
public static bool TryGetMemberWithSameSignatureFromType(CSharpType type, CSharpMember memberToMatch, out CSharpMember member)
{
Contract.Requires(type != null);
Contract.Requires(memberToMatch != null);
Contract.Ensures(!Contract.Result <bool>() || Contract.ValueAtReturn(out member) != null);
member = null;
var members = type.Members;
if (members == null)
{
throw new IllFormedSemanticModelException("A CSharpType was found with a null 'Members' field.", type);
}
foreach (var m in members)
{
if (m == null)
{
throw new IllFormedSemanticModelException("An null 'member' was found in a CSharpType's 'Members' field.", type);
}
if (MembersAreEquivalent(m, memberToMatch))
{
member = m;
return(true);
}
}
return(false);
}
public bool TryGetPropertyContract(CSharpMember semanticMember, out IMethodContract getterContract, out IMethodContract setterContract)
{
Contract.Requires(semanticMember == null || semanticMember.IsProperty || semanticMember.IsIndexer);
getterContract = null;
setterContract = null;
#region Check input
if (semanticMember == null)
{
return(false);
}
#endregion
IMethodReference getter, setter;
if (!TryGetPropertyAccessorReferences(semanticMember, out getter, out setter))
{
return(false);
}
var success = false;
if (getter != null)
{
success |= TryGetMethodContract(getter, out getterContract);
}
if (setter != null)
{
success |= TryGetMethodContract(setter, out setterContract);
}
return(success);
}
private string GetFormattedContracts(CSharpMember semanticMember)
{
Contract.Requires(semanticMember != null);
Contract.Requires(semanticMember.IsMethod || semanticMember.IsConstructor || semanticMember.IsProperty || semanticMember.IsIndexer);
if (semanticMember.IsProperty || semanticMember.IsIndexer)
{
IMethodContract setter, getter;
if (!((ContractsProvider)_textViewTracker.ProjectTracker.ContractsProvider).TryGetPropertyContract(semanticMember, out getter, out setter))
{
return(null);
}
return(IntellisenseContractsHelper.FormatPropertyContracts(getter, setter));
}
//Can we get our contracts?
IMethodContract methodContracts;
if (!((ContractsProvider)_textViewTracker.ProjectTracker.ContractsProvider).TryGetMethodContract(semanticMember, out methodContracts))
{
return(null);
}
//Can we get our formatted contracts?
return(IntellisenseContractsHelper.FormatContracts(methodContracts));
}
private IEnumerable <CSharpMember> FindHideBySigMethod(CSharpType type, CSharpMember member, bool checkBaseTypes, bool includeInheritedInterfaces)
{
List <CSharpMember> results = new List <CSharpMember>();
FindHideBySigMethod(results, type, member, checkBaseTypes, includeInheritedInterfaces);
return(results);
}
public static CSharpMember Uninstantiate(this CSharpMember member)
{
Contract.Requires(member != null);
Contract.Ensures(Contract.Result <CSharpMember>() != null);
Contract.Ensures(member.IsMethod == Contract.Result <CSharpMember>().IsMethod);
Contract.Ensures(member.IsConstructor == Contract.Result <CSharpMember>().IsConstructor);
Contract.Ensures(member.IsProperty == Contract.Result <CSharpMember>().IsProperty);
Contract.Ensures(member.IsIndexer == Contract.Result <CSharpMember>().IsIndexer);
var uninstantiatedMember = member;
var definingMember = member.DefiningMember;
while (definingMember != null)
{
uninstantiatedMember = definingMember;
definingMember = definingMember.DefiningMember;
}
Contract.Assume(member.IsMethod == uninstantiatedMember.IsMethod);
Contract.Assume(member.IsConstructor == uninstantiatedMember.IsConstructor);
Contract.Assume(member.IsProperty == uninstantiatedMember.IsProperty);
Contract.Assume(member.IsIndexer == uninstantiatedMember.IsIndexer);
return(uninstantiatedMember);
}
protected override void OnExecute(Microsoft.VisualStudio.Shell.OleMenuCommand command)
{
int curLineIndex, curColumnIndex;
VSTextView textView = new VSTextView(VSTextView.ActiveTextView);
if (textView == null)
{
MessageBox.Show("textView is null");
return;
}
textView.GetCursorPositon(out curLineIndex, out curColumnIndex);
//帮助：http://social.msdn.microsoft.com/Forums/en-US/vsx/thread/c62a70eb-d84c-4410-890d-b41a86b2b55f/
ILangService langService;
LangService_GetInstance(out langService);
if (langService == null)
{
MessageBox.Show("langService is null");
return;
}
IDECompilerHost compilerHost = new IDECompilerHost();
IProject prj;
Project currentPro = VSDocument.ActiveDocument.ProjectItem.ContainingProject;
LangService_GetDteProject(langService, currentPro, out prj);
if (prj == null)
{
MessageBox.Show("prj is null");
return;
}
FileName fileName = new Microsoft.RestrictedUsage.CSharp.Core.FileName(VSDocument.ActiveDocument.FullName);
CSRPOSDATA data = new CSRPOSDATA()
{
LineIndex = curLineIndex, ColumnIndex = curColumnIndex
};
CSharpMember m = Utilities.GetMemberAtLocation(compilerHost, prj, fileName.Value, data);
if (m != null && m.ReturnType != null)
{
string returnName = m.ReturnType.GetFormattedName(InteropTypeFormatFlags.TypeFormatFlags_BestNameGUI);
returnName = FilterReturnName(returnName);
if (string.IsNullOrEmpty(returnName))
{
return;
}
int insertCol = GetInsertPosition(textView, curLineIndex, curColumnIndex);
textView.InsertText(returnName + " v =", curLineIndex, insertCol);
textView.SelectText(curLineIndex, insertCol + returnName.Length + 1, curLineIndex, insertCol + returnName.Length + 2);
}
}
public static void NavigateToMember(CSharpMemberIdentifier memberIdentifier)
{
bool result = false;
try
{
CSharpMember currentMember = ResolveMember(memberIdentifier);
if (currentMember == null)
{
return;
}
var sourceLocations = currentMember.SourceLocations;
if (sourceLocations == null || sourceLocations.Count == 0)
{
return;
}
var location = sourceLocations[0];
if (location.FileName == null || !location.Position.IsValid)
{
return;
}
CSRPOSDATA position = new CSRPOSDATA()
{
LineIndex = location.Position.Line,
ColumnIndex = location.Position.Character
};
ILangService languageService;
CSharpInheritanceAnalyzer.LangService_GetInstance(out languageService);
if (languageService == null)
{
return;
}
IProject project = null;
languageService.OpenSourceFile(project, location.FileName.Value, position);
}
catch (ApplicationException)
{
////_callHierarchy.LanguageService.DisplayErrorMessage(exception.Message);
return;
}
catch (InvalidOperationException)
{
////this._callHierarchy.LanguageService.DisplayErrorMessage(exception2.Message);
return;
}
if (!result)
{
////NativeMessageId.Create(this._callHierarchy.LanguageService, jrc_StringResource_identifiers.IDS_HIDDEN_DEFINITION, new object[0]).DisplayError(this._callHierarchy.LanguageService);
}
}
public ISet <CSharpMemberIdentifier> GetImplementorsForInterfaceMember(CSharpMemberIdentifier memberId)
{
CSharpMember member = CSharpInheritanceAnalyzer.ResolveMemberIdentifier(AllProjects, memberId).Item1;
ISet <CSharpMemberIdentifier> resultList = CreateHashSet <CSharpMemberIdentifier>(new CSharpMemberIdentifierEqualityComparer());
if (!IsSupportedMemberType(member))
{
return(resultList);
}
AddImplementorsForInterfaceMember(member, resultList);
return(resultList);
}
public ISet <CSharpMemberIdentifier> GetOverridersFromDerivedTypes(CSharpMemberIdentifier memberId)
{
CSharpMember member = CSharpInheritanceAnalyzer.ResolveMemberIdentifier(AllProjects, memberId).Item1;
ISet <CSharpMemberIdentifier> resultList = CreateHashSet <CSharpMemberIdentifier>(new CSharpMemberIdentifierEqualityComparer());
if (!IsSupportedMemberType(member))
{
return(resultList);
}
AddVirtualOverridersFromDerivedTypes(member, resultList);
return(resultList);
}
public bool TryGetMethodContractSafe(CSharpMember semanticMehod, out IMethodContract methodContract)
{
Contract.Requires(semanticMehod == null || semanticMehod.IsMethod || semanticMehod.IsConstructor);
Contract.Ensures(!Contract.Result <bool>() || (Contract.ValueAtReturn(out methodContract) != null));
methodContract = null;
#region Check input
if (semanticMehod == null)
{
return(false);
}
#endregion
#region Call TryGetMethodContract cautiously
try {
//Can we get contracts?
if (!TryGetMethodContract(semanticMehod, out methodContract))
{
return(false);
}
}
#endregion
#region Abort on exception
//Give up on our contracts if we get an exception
catch (IllFormedSemanticModelException) {
return(false);
} catch (InvalidOperationException e) {
if (!e.Message.Contains(ContractsPackageAccessor.InvalidOperationExceptionMessage_TheSnapshotIsOutOfDate))
{
throw e;
}
else
{
return(false);
}
} catch (System.Runtime.InteropServices.COMException e) {
if (!e.Message.Contains(ContractsPackageAccessor.COMExceptionMessage_BindingFailed))
{
throw e;
}
else
{
return(false);
}
}
#endregion
return(methodContract != null);
}
public static CallingConvention GetCallingConventionFor(CSharpMember semanticMember)
{
Contract.Requires(semanticMember != null);
var callingConvention = CallingConvention.Default;
if (semanticMember.IsMethod)
{
if (semanticMember.TypeParameters != null && semanticMember.TypeParameters.Count > 0)
{
callingConvention = callingConvention | CallingConvention.Generic;
}
}
if (!semanticMember.IsStatic)
{
callingConvention = callingConvention | CallingConvention.HasThis;
}
return(callingConvention);
}
public bool TryGetMethodContract(CSharpMember semanticMethod, out IMethodContract methodContract)
{
Contract.Requires(semanticMethod == null || semanticMethod.IsConstructor || semanticMethod.IsMethod);
Contract.Ensures(!Contract.Result <bool>() || (Contract.ValueAtReturn(out methodContract) != null));
methodContract = null;
#region Check input
if (semanticMethod == null)
{
return(false);
}
#endregion
#region Try get the reference then check for contracts
IMethodReference cciMethod;
if (TryGetMethodReference(semanticMethod, out cciMethod))
{
if (TryGetMethodContract(cciMethod, out methodContract))
{
return(true);
}
else
{
//No need, detailed logs are written at all code paths in "TryGetMethodContract"
//ContractsPackageAccessor.Current.Logger.WriteToLog("Failed to get method contracts for: " + cciMethod.Name);
}
}
else
{
methodContract = null;
if (semanticMethod.Name != null)
{
ContractsPackageAccessor.Current.Logger.WriteToLog("Failed to get CCI reference for: " + semanticMethod.Name.Text);
}
}
return(false);
#endregion
}
public static bool TryGetBaseMember(CSharpMember member, out CSharpMember baseMember)
{
Contract.Requires(member != null);
Contract.Ensures(!Contract.Result <bool>() ||
member.IsMethod == Contract.ValueAtReturn(out baseMember).IsMethod &&
member.IsProperty == Contract.ValueAtReturn(out baseMember).IsProperty &&
member.IsIndexer == Contract.ValueAtReturn(out baseMember).IsIndexer &&
member.IsField == Contract.ValueAtReturn(out baseMember).IsField);
baseMember = null;
if (member.ContainingType == null)
{
throw new IllFormedSemanticModelException("A CSharpMember (method) was found with a null 'ContainingType' field.", member);
}
if (!member.ContainingType.IsClass)
{
return(false);
}
var containingType = member.ContainingType;
var baseClass = containingType.BaseClass;
while (baseClass != null)
{
if (TryGetMemberWithSameSignatureFromType(baseClass, member, out baseMember))
{
Contract.Assume(
member.IsMethod == baseMember.IsMethod &&
member.IsProperty == baseMember.IsProperty &&
member.IsIndexer == baseMember.IsIndexer &&
member.IsField == baseMember.IsField);
return(true);
}
baseClass = baseClass.BaseClass;
}
return(false);
}
static void RecursivelyLookupContractsForProperties(InheritanceTracker @this)
{
Contract.Requires(@this != null);
#region Dequeue
if (@this._propertiesNeedingContractLookup.Count < 1)
{
return;
}
var propertyPair = @this._propertiesNeedingContractLookup.Dequeue();
var property = propertyPair.Value;
var tagTuple = propertyPair.Key;
#endregion
try {
var comp = @this._textViewTracker.LatestCompilation;
if (comp == null)
{
ContractsPackageAccessor.Current.Logger.WriteToLog("No LatestCompilation, waiting for a new semantic model.");
@this._textViewTracker.IsLatestCompilationStale = true;
Utilities.Delay(() => ContractsPackageAccessor.Current.AskForNewVSModel(), DelayOnVSModelFailedBeforeTryingAgain);
@this.semanticModelsFetchedCounter++;
goto RequeueAndAbort;
}
#region Get semantic property from syntactic property
CSharpMember semanticProperty = null;
semanticProperty = comp.GetMemberForPropertyDeclaration(property);
if (semanticProperty == null)
{
if (@this.trackingNumberOfFetchedSemanticModels && @this.semanticModelsFetchedCounter <= 3)
{
ContractsPackageAccessor.Current.Logger.WriteToLog("Failed to get semantic property from syntactic property, waiting for a new semantic model.");
@this._textViewTracker.IsLatestCompilationStale = true;
Utilities.Delay(() => ContractsPackageAccessor.Current.AskForNewVSModel(), DelayOnVSModelFailedBeforeTryingAgain);
@this.semanticModelsFetchedCounter++;
goto RequeueAndAbort;
}
else
{
ContractsPackageAccessor.Current.Logger.WriteToLog("Failed to get semantic property from syntactic property. Too many semantic models have already been fetched, skipping this property...");
goto Continue;
}
}
#endregion
#region Try get the property that this property is inherited from
CSharpMember inheritedFromProperty;
if (!TryGetIheritedFromMember(semanticProperty, property.Parent as TypeDeclarationNode, out inheritedFromProperty))
{
goto Continue;
}
#endregion
#region Uninstantiated property
semanticProperty = semanticProperty.Uninstantiate();
#endregion
#region Get our tool tip
var toolTip = "";
if (!semanticProperty.IsAbstract && !semanticProperty.ContainingType.IsInterface)
{
toolTip = String.Format("Contracts inherited from {0}.", inheritedFromProperty.ContainingType.Name.Text);
}
#endregion
#region Try get accessor contracts and update adornment
IMethodReference getterReference = null;
IMethodReference setterReference = null;
if (((ContractsProvider)@this._textViewTracker.ProjectTracker.ContractsProvider).TryGetPropertyAccessorReferences(inheritedFromProperty, out getterReference, out setterReference))
{
if (tagTuple.Item1 != null && getterReference != null)
{
IMethodContract getterContracts;
if (((ContractsProvider)@this._textViewTracker.ProjectTracker.ContractsProvider).TryGetMethodContract(getterReference, out getterContracts))
{
var possibleAdornment = @this._adornmentManager.GetAdornment(tagTuple.Item1);
if (possibleAdornment != null)
{
var adornment = possibleAdornment as ContractAdornment;
if (adornment != null)
{
adornment.SetContracts(getterContracts, toolTip);
}
else
{
ContractsPackageAccessor.Current.Logger.WriteToLog("Placeholder adornment isn't a ContractAdornment (not good!), skipping getter...");
}
}
else
{
ContractsPackageAccessor.Current.Logger.WriteToLog("Placeholder adornment not found, skipping getter...");
}
}
}
if (tagTuple.Item2 != null && setterReference != null)
{
IMethodContract setterContracts;
if (((ContractsProvider)@this._textViewTracker.ProjectTracker.ContractsProvider).TryGetMethodContract(setterReference, out setterContracts))
{
var possibleAdornment = @this._adornmentManager.GetAdornment(tagTuple.Item2);
if (possibleAdornment != null)
{
var adornment = possibleAdornment as ContractAdornment;
if (adornment != null)
{
adornment.SetContracts(setterContracts, toolTip);
}
else
{
ContractsPackageAccessor.Current.Logger.WriteToLog("Placeholder adornment isn't a ContractAdornment (not good!), skipping setter...");
}
}
else
{
ContractsPackageAccessor.Current.Logger.WriteToLog("Placeholder adornment not found, skipping setter...");
}
}
}
}
else
{
ContractsPackageAccessor.Current.Logger.WriteToLog("Failed to get CCI reference for: " + inheritedFromProperty.Name.Text);
}
#endregion
}
#region Exception handeling
catch (IllFormedSemanticModelException e) {
if (@this.trackingNumberOfFetchedSemanticModels && @this.semanticModelsFetchedCounter <= 2)
{
ContractsPackageAccessor.Current.Logger.WriteToLog("Error: An 'IllFormedSemanticModelException' occured: '" + e.Message + "' Asking for a new semantic model...");
@this._textViewTracker.IsLatestCompilationStale = true;
ContractsPackageAccessor.Current.AskForNewVSModel();
@this.semanticModelsFetchedCounter++;
goto RequeueAndAbort;
}
else
{
ContractsPackageAccessor.Current.Logger.WriteToLog("An 'IllFormedSemanticModelException' occured: '" + e.Message + "' Too many semantic models have been fetched, skipping this property...");
goto Continue;
}
} catch (InvalidOperationException e) {
if (e.Message.Contains(ContractsPackageAccessor.InvalidOperationExceptionMessage_TheSnapshotIsOutOfDate))
{
if (@this.trackingNumberOfFetchedSemanticModels && @this.semanticModelsFetchedCounter <= 5)
{
ContractsPackageAccessor.Current.Logger.WriteToLog("The Visual Studio Semantic/Syntactic model threw an exception (it's snapshot is out of date) while looking up contracts, getting new compilation...");
@this._textViewTracker.IsLatestCompilationStale = true;
ContractsPackageAccessor.Current.AskForNewVSModel();
@this.semanticModelsFetchedCounter++;
goto RequeueAndAbort;
}
else
{
ContractsPackageAccessor.Current.Logger.WriteToLog("The Visual Studio Semantic/Syntactic model threw an exception (it's snapshot is out of date) while looking up contracts. Too many compilations have already been fetched, skipping this property...");
goto Continue;
}
}
else
{
throw e;
}
} catch (COMException e) {
if (e.Message.Contains(ContractsPackageAccessor.COMExceptionMessage_BindingFailed))
{
if (@this.trackingNumberOfFetchedSemanticModels && @this.semanticModelsFetchedCounter <= 5)
{
ContractsPackageAccessor.Current.Logger.WriteToLog("The Visual Studio Semantic/Syntactic model threw an exception (it's snapshot is out of date) while looking up contracts, getting new compilation...");
@this._textViewTracker.IsLatestCompilationStale = true;
ContractsPackageAccessor.Current.AskForNewVSModel();
@this.semanticModelsFetchedCounter++;
goto RequeueAndAbort;
}
else
{
ContractsPackageAccessor.Current.Logger.WriteToLog("The Visual Studio Semantic/Syntactic model threw an exception (it's snapshot is out of date) while looking up contracts. Too many compilations have already been fetched, skipping this property...");
goto Continue;
}
}
else
{
throw e;
}
}
#endregion
Continue:
ContractsPackageAccessor.Current.QueueWorkItem(() => RecursivelyLookupContractsForProperties(@this));
return;
RequeueAndAbort:
@this._propertiesNeedingContractLookup.Enqueue(propertyPair);
return;
}
private void FindHideBySigMethod(List <CSharpMember> results, CSharpType type, CSharpMember member, bool checkBaseTypes, bool includeInheritedInterfaces)
{
foreach (var potential in type.Members)
{
if (!member.IsSameSignature(potential))
{
continue;
}
results.Add(potential);
}
if (checkBaseTypes)
{
CSharpType baseType = type.BaseClass;
if (baseType != null)
{
FindHideBySigMethod(results, baseType, member, checkBaseTypes, includeInheritedInterfaces);
}
}
if (includeInheritedInterfaces)
{
IList <CSharpType> interfaces = type.BaseInterfaces;
if (interfaces != null)
{
foreach (CSharpType interfaceType in interfaces.OfType <CSharpType>())
{
FindHideBySigMethod(results, interfaceType, member, checkBaseTypes, includeInheritedInterfaces);
}
}
}
}
public bool TryGetMethodContractSafe(CSharpMember semanticMehod, out IMethodContract methodContract) {
Contract.Requires(semanticMehod == null || semanticMehod.IsMethod || semanticMehod.IsConstructor);
Contract.Ensures(!Contract.Result<bool>() || (Contract.ValueAtReturn(out methodContract) != null));
methodContract = null;
#region Check input
if (semanticMehod == null) {
return false;
}
#endregion
#region Call TryGetMethodContract cautiously
try {
//Can we get contracts?
if (!TryGetMethodContract(semanticMehod, out methodContract))
return false;
}
#endregion
#region Abort on exception
//Give up on our contracts if we get an exception
catch (IllFormedSemanticModelException) {
return false;
} catch (InvalidOperationException e) {
if (!e.Message.Contains(VSServiceProvider.InvalidOperationExceptionMessage_TheSnapshotIsOutOfDate))
throw e;
else
return false;
} catch (System.Runtime.InteropServices.COMException e) {
if (!e.Message.Contains(VSServiceProvider.COMExceptionMessage_BindingFailed))
throw e;
else
return false;
}
#endregion
return methodContract != null;
}
public bool TryGetMethodReference(CSharpMember semanticMethod, out IMethodReference cciMethod) {
Contract.Requires(semanticMethod == null || semanticMethod.IsConstructor || semanticMethod.IsMethod);
Contract.Ensures(!Contract.Result<bool>() || Contract.ValueAtReturn(out cciMethod) != null);
cciMethod = null;
#region Check input
if (semanticMethod == null) {
return false;
}
#endregion
#region Check cache
if (VSServiceProvider.Current.VSOptionsPage.Caching)
if (_semanticMembersToCCIMethods.TryGetValue(semanticMethod, out cciMethod))
return (!(cciMethod is Dummy)) && cciMethod != null;
#endregion
#region Set up our working cci method
var workingCciMethod = new Microsoft.Cci.MutableCodeModel.MethodReference();
#endregion
#region Set the intern factory
workingCciMethod.InternFactory = Host.InternFactory;
#endregion
#region Get calling conventions
workingCciMethod.CallingConvention = CSharpToCCIHelper.GetCallingConventionFor(semanticMethod);
#endregion
#region Get containing type reference
ITypeReference containingType;
if (!TryGetTypeReference(semanticMethod.ContainingType, out containingType))
goto ReturnFalse;
workingCciMethod.ContainingType = containingType;
#endregion
#region Get return type reference
if (semanticMethod.IsConstructor)
workingCciMethod.Type = this.Host.PlatformType.SystemVoid;
else {
ITypeReference returnType;
if (!TryGetTypeReference(semanticMethod.ReturnType, out returnType))
goto ReturnFalse;
workingCciMethod.Type = returnType;
}
#endregion
#region Get name
if (!semanticMethod.IsConstructor && semanticMethod.Name == null) goto ReturnFalse;
workingCciMethod.Name = Host.NameTable.GetNameFor(semanticMethod.IsConstructor?".ctor":semanticMethod.Name.Text);
#endregion
#region Get generic param count
if (semanticMethod.TypeParameters == null)
workingCciMethod.GenericParameterCount = 0;
else
workingCciMethod.GenericParameterCount = (ushort)semanticMethod.TypeParameters.Count;
#endregion
#region Get parameter references
List<IParameterTypeInformation> cciParameters;
if (semanticMethod.Parameters == null) goto ReturnFalse;
Contract.Assume(semanticMethod.Parameters.Count <= ushort.MaxValue, "Should be a postcondition?");
if (!TryGetParametersList(semanticMethod.Parameters, out cciParameters))
goto ReturnFalse;
workingCciMethod.Parameters = cciParameters;
#endregion
#region Get the assembly reference (this also ensures the assembly gets loaded properly)
IAssemblyReference assemblyReference;
TryGetAssemblyReference(semanticMethod.Assembly, out assemblyReference);
#endregion
cciMethod = workingCciMethod;
return true;
#region ReturnFalse:
ReturnFalse:
cciMethod = Dummy.MethodReference;
if (VSServiceProvider.Current.VSOptionsPage.Caching)
_semanticMembersToCCIMethods[semanticMethod] = cciMethod;
return false;
#endregion
}
public bool TryGetPropertyAccessorReferences(CSharpMember semanticProperty, out IMethodReference getter, out IMethodReference setter) {
Contract.Requires(semanticProperty == null || semanticProperty.IsProperty || semanticProperty.IsIndexer);
getter = setter = null;
#region Check input
if (semanticProperty == null) {
return false;
}
#endregion
#region Check cache
Tuple<IMethodReference, IMethodReference> cacheOutput;
if (_semanticPropertiesToCCIAccessorMethods.TryGetValue(semanticProperty, out cacheOutput)) {
Contract.Assume(cacheOutput != null, "Non-null only dictionary");
getter = cacheOutput.Item1;
setter = cacheOutput.Item2;
return (getter != null && getter != Dummy.MethodReference) || (setter != null && setter != Dummy.MethodReference);
}
#endregion
#region Get calling conventions
var callingConventions = CSharpToCCIHelper.GetCallingConventionFor(semanticProperty);
#endregion
#region get containing type
ITypeReference containingType;
if (!TryGetTypeReference(semanticProperty.ContainingType, out containingType))
goto ReturnFalse;
#endregion
#region Get return type
ITypeReference returnType;
if (!TryGetTypeReference(semanticProperty.ReturnType, out returnType))
goto ReturnFalse;
#endregion
#region Get the property's name
string propertyName;
if (semanticProperty.IsIndexer)
propertyName = "Item";
else
{
if (semanticProperty.Name == null) goto ReturnFalse;
propertyName = semanticProperty.Name.Text;
}
#endregion
#region Get the parameters
List<IParameterTypeInformation> getterParams;
if (semanticProperty.Parameters != null) {
if (!TryGetParametersList(semanticProperty.Parameters, out getterParams))
goto ReturnFalse;
} else
getterParams = new List<IParameterTypeInformation>();
List<IParameterTypeInformation> setterParams;
if (semanticProperty.Parameters != null) {
if (!TryGetParametersList(semanticProperty.Parameters, out setterParams, 1))
goto ReturnFalse;
#region Append the "value" param
var valParam = new Microsoft.Cci.MutableCodeModel.ParameterTypeInformation() {
Type = returnType,
Index = 0,
IsByReference = false
};
setterParams.Insert(0, valParam);
#endregion
} else
setterParams = new List<IParameterTypeInformation>();
#endregion
#region Build the getter
getter = new Microsoft.Cci.MutableCodeModel.MethodReference() {
InternFactory = Host.InternFactory,
CallingConvention = callingConventions,
ContainingType = containingType,
Type = returnType,
Name = Host.NameTable.GetNameFor("get_" + propertyName),
GenericParameterCount = 0,
Parameters = getterParams
};
#endregion
#region Build the setter
setter = new Microsoft.Cci.MutableCodeModel.MethodReference() {
InternFactory = Host.InternFactory,
CallingConvention = callingConventions,
ContainingType = containingType,
Type = Host.PlatformType.SystemVoid,
Name = Host.NameTable.GetNameFor("set_" + propertyName),
GenericParameterCount = 0,
Parameters = setterParams
};
#endregion
#region Get the assembly reference (this also ensures the assembly gets loaded properly)
IAssemblyReference assemblyReference;
TryGetAssemblyReference(semanticProperty.Assembly, out assemblyReference);
#endregion
#region ReturnTrue:
//ReturnTrue:
_semanticPropertiesToCCIAccessorMethods[semanticProperty] = new Tuple<IMethodReference, IMethodReference>(getter, setter);
return true;
#endregion
#region ReturnFalse:
ReturnFalse:
if (semanticProperty.Name != null)
{
VSServiceProvider.Current.Logger.WriteToLog("Failed to build accessor references for: " + semanticProperty.Name.Text);
}
_semanticPropertiesToCCIAccessorMethods[semanticProperty] = new Tuple<IMethodReference, IMethodReference>(Dummy.MethodReference, Dummy.MethodReference);
return false;
#endregion
}
public static bool MembersAreEquivalent(CSharpMember member1, CSharpMember member2)
{
Contract.Requires(member1 != null);
Contract.Requires(member2 != null);
#region Check kind
if (member1.IsProperty ^ member2.IsProperty)
{
return(false);
}
if (member1.IsMethod ^ member2.IsMethod)
{
return(false);
}
if (member1.IsField ^ member2.IsField)
{
return(false);
}
if (member1.IsIndexer ^ member2.IsIndexer)
{
return(false);
}
#endregion
#region Check name
if (member1.Name == null ^ member2.Name == null)
{
return(false);
}
if (member1.Name != null && member2.Name != null &&
!member1.Name.Equals(member2.Name))
{
return(false);
}
#endregion
#region Check explicit interface implementation
if (member1.ExplicitInterfaceImplementation != null ^ member2.ExplicitInterfaceImplementation != null)
{
return(false);
}
if (member1.ExplicitInterfaceImplementation != null && member2.ExplicitInterfaceImplementation != null &&
!TypesAreEquivalent(member1.ExplicitInterfaceImplementation, member2.ExplicitInterfaceImplementation))
{
return(false);
}
#endregion
#region Check parameters
if (member1.Parameters == null ^ member2.Parameters == null)
{
return(false);
}
if (member1.Parameters != null && member2.Parameters != null &&
!ParameterListsAreEquivalent(member1.Parameters, member2.Parameters))
{
return(false);
}
#endregion
#region Check return type
if (member1.ReturnType == null)
{
throw new IllFormedSemanticModelException("A CSharpMember (member) was found with a null 'ReturnType' field.", member1);
}
if (member2.ReturnType == null)
{
throw new IllFormedSemanticModelException("A CSharpMember (member) was found with a null 'ReturnType' field.", member2);
}
if (!TypesAreEquivalent(member1.ReturnType, member2.ReturnType))
{
return(false);
}
#endregion
return(true);
}
internal RuntimeFieldInfo(CSharpMember member)
{
this.member = member;
}
/* * 调用实现 * 1. 穷举所有类型所有成员的调用 * 优：各语言通用，不依赖语言支持反射的变式实现，执行速度快 * 劣：生成代码多（引用优化和手动添加反射标签，应该也不会太多） */ [ANonOptimize][AInvariant] public extern static object Invoke(CSharpMember member, object obj, object[] args);
static void RecursivelyLookupContractsForMethods(InheritanceTracker @this)
{
Contract.Requires(@this != null);
#region Dequeue
if (@this._methodsNeedingContractLookup.Count < 1)
{
return;
}
var methodPair = @this._methodsNeedingContractLookup.Dequeue();
var method = methodPair.Value;
var tag = methodPair.Key;
#endregion
try {
VSServiceProvider.Current.Logger.WriteToLog(String.Format("Attempting to lookup contracts for '{0}'", tag.ToString()));
var comp = @this._textViewTracker.LatestCompilation;
if (comp == null)
{
VSServiceProvider.Current.Logger.WriteToLog("No LatestCompilation, waiting for a new semantic model.");
@this._textViewTracker.IsLatestCompilationStale = true;
Utilities.Delay(() => VSServiceProvider.Current.AskForNewVSModel(), DelayOnVSModelFailedBeforeTryingAgain);
@this.semanticModelsFetchedCounter++;
goto RequeueAndAbort;
}
#region Get semantic method from syntactic method
CSharpMember semanticMethod = null;
semanticMethod = comp.GetMemberForMethodDeclaration(method);
if (semanticMethod == null)
{
if (@this.trackingNumberOfFetchedSemanticModels && @this.semanticModelsFetchedCounter <= 3)
{
VSServiceProvider.Current.Logger.WriteToLog("Failed to get semantic method from syntactic method, waiting for a new semantic model.");
@this._textViewTracker.IsLatestCompilationStale = true;
Utilities.Delay(() => VSServiceProvider.Current.AskForNewVSModel(), DelayOnVSModelFailedBeforeTryingAgain);
@this.semanticModelsFetchedCounter++;
goto RequeueAndAbort;
}
else
{
VSServiceProvider.Current.Logger.WriteToLog("Failed to get semantic method from syntactic method. Too many semantic models have already been fetched, skipping this method...");
goto Continue;
}
}
#endregion
#region Try get the method that this method is inherited from
CSharpMember inheritedFromMethod;
if (!TryGetIheritedFromMember(semanticMethod, method.Parent as TypeDeclarationNode, out inheritedFromMethod))
{
goto Continue;
}
#endregion
#region Uninstantiated method
semanticMethod = semanticMethod.Uninstantiate();
#endregion
#region Get our tool tip
var toolTip = "";
if (!semanticMethod.IsAbstract && !semanticMethod.ContainingType.IsInterface)
{
toolTip = String.Format("Contracts inherited from {0}.", inheritedFromMethod.ContainingType.Name.Text);
}
#endregion
#region Try get method contracts and update adornment
IMethodContract contracts = null;
if (@this._textViewTracker.ProjectTracker.ContractsProvider.TryGetMethodContract(inheritedFromMethod, out contracts))
{
var possibleAdornment = @this._adornmentManager.GetAdornment(tag);
if (possibleAdornment != null)
{
var adornment = possibleAdornment as ContractAdornment;
if (adornment != null)
{
adornment.SetContracts(contracts, toolTip);
}
else
{
VSServiceProvider.Current.Logger.WriteToLog("Placeholder adornment isn't a ContractAdornment (not good!), skipping method...");
}
}
else
{
VSServiceProvider.Current.Logger.WriteToLog("Placeholder adornment not found, skipping method...");
}
}
#endregion
}
#region Exception handeling
catch (IllFormedSemanticModelException e) {
if (@this.trackingNumberOfFetchedSemanticModels && @this.semanticModelsFetchedCounter <= 2)
{
VSServiceProvider.Current.Logger.WriteToLog("Error: An 'IllFormedSemanticModelException' occured: '" + e.Message + "' Asking for a new semantic model...");
@this._textViewTracker.IsLatestCompilationStale = true;
VSServiceProvider.Current.AskForNewVSModel();
@this.semanticModelsFetchedCounter++;
goto RequeueAndAbort;
}
else
{
VSServiceProvider.Current.Logger.WriteToLog("An 'IllFormedSemanticModelException' occured: '" + e.Message + "' Too many semantic models have been fetched, skipping this method...");
goto Continue;
}
} catch (InvalidOperationException e) {
if (e.Message.Contains(VSServiceProvider.InvalidOperationExceptionMessage_TheSnapshotIsOutOfDate))
{
if (@this.trackingNumberOfFetchedSemanticModels && @this.semanticModelsFetchedCounter <= 5)
{
VSServiceProvider.Current.Logger.WriteToLog("The Visual Studio Semantic/Syntactic model threw an exception (it's snapshot is out of date) while looking up contracts, getting new compilation...");
@this._textViewTracker.IsLatestCompilationStale = true;
VSServiceProvider.Current.AskForNewVSModel();
@this.semanticModelsFetchedCounter++;
goto RequeueAndAbort;
}
else
{
VSServiceProvider.Current.Logger.WriteToLog("The Visual Studio Semantic/Syntactic model threw an exception (it's snapshot is out of date) while looking up contracts. Too many compilations have already been fetched, skipping this method...");
goto Continue;
}
}
else
{
throw e;
}
} catch (COMException e) {
if (e.Message.Contains(VSServiceProvider.COMExceptionMessage_BindingFailed))
{
if (@this.trackingNumberOfFetchedSemanticModels && @this.semanticModelsFetchedCounter <= 5)
{
VSServiceProvider.Current.Logger.WriteToLog("The Visual Studio Semantic/Syntactic model threw an exception (it's snapshot is out of date) while looking up contracts, getting new compilation...");
@this._textViewTracker.IsLatestCompilationStale = true;
VSServiceProvider.Current.AskForNewVSModel();
@this.semanticModelsFetchedCounter++;
goto RequeueAndAbort;
}
else
{
VSServiceProvider.Current.Logger.WriteToLog("The Visual Studio Semantic/Syntactic model threw an exception (it's snapshot is out of date) while looking up contracts. Too many compilations have already been fetched, skipping this method...");
goto Continue;
}
}
else
{
throw e;
}
}
#endregion
Continue:
VSServiceProvider.Current.QueueWorkItem(() => RecursivelyLookupContractsForMethods(@this));
return;
RequeueAndAbort:
@this._methodsNeedingContractLookup.Enqueue(methodPair);
return;
}
public bool TryGetPropertyAccessorReferences(CSharpMember semanticProperty, out IMethodReference getter, out IMethodReference setter)
{
Contract.Requires(semanticProperty == null || semanticProperty.IsProperty || semanticProperty.IsIndexer);
getter = setter = null;
#region Check input
if (semanticProperty == null)
{
return(false);
}
#endregion
#region Check cache
Tuple <IMethodReference, IMethodReference> cacheOutput;
if (_semanticPropertiesToCCIAccessorMethods.TryGetValue(semanticProperty, out cacheOutput))
{
Contract.Assume(cacheOutput != null, "Non-null only dictionary");
getter = cacheOutput.Item1;
setter = cacheOutput.Item2;
return((getter != null && getter != Dummy.MethodReference) || (setter != null && setter != Dummy.MethodReference));
}
#endregion
#region Get calling conventions
var callingConventions = CSharpToCCIHelper.GetCallingConventionFor(semanticProperty);
#endregion
#region get containing type
ITypeReference containingType;
if (!TryGetTypeReference(semanticProperty.ContainingType, out containingType))
{
goto ReturnFalse;
}
#endregion
#region Get return type
ITypeReference returnType;
if (!TryGetTypeReference(semanticProperty.ReturnType, out returnType))
{
goto ReturnFalse;
}
#endregion
#region Get the property's name
string propertyName;
if (semanticProperty.IsIndexer)
{
propertyName = "Item";
}
else
{
if (semanticProperty.Name == null)
{
goto ReturnFalse;
}
propertyName = semanticProperty.Name.Text;
}
#endregion
#region Get the parameters
List <IParameterTypeInformation> getterParams;
if (semanticProperty.Parameters != null)
{
if (!TryGetParametersList(semanticProperty.Parameters, out getterParams))
{
goto ReturnFalse;
}
}
else
{
getterParams = new List <IParameterTypeInformation>();
}
List <IParameterTypeInformation> setterParams;
if (semanticProperty.Parameters != null)
{
if (!TryGetParametersList(semanticProperty.Parameters, out setterParams, 1))
{
goto ReturnFalse;
}
#region Append the "value" param
var valParam = new Microsoft.Cci.MutableCodeModel.ParameterTypeInformation()
{
Type = returnType,
Index = 0,
IsByReference = false
};
setterParams.Insert(0, valParam);
#endregion
}
else
{
setterParams = new List <IParameterTypeInformation>();
}
#endregion
#region Build the getter
getter = new Microsoft.Cci.MutableCodeModel.MethodReference()
{
InternFactory = Host.InternFactory,
CallingConvention = callingConventions,
ContainingType = containingType,
Type = returnType,
Name = Host.NameTable.GetNameFor("get_" + propertyName),
GenericParameterCount = 0,
Parameters = getterParams
};
#endregion
#region Build the setter
setter = new Microsoft.Cci.MutableCodeModel.MethodReference()
{
InternFactory = Host.InternFactory,
CallingConvention = callingConventions,
ContainingType = containingType,
Type = Host.PlatformType.SystemVoid,
Name = Host.NameTable.GetNameFor("set_" + propertyName),
GenericParameterCount = 0,
Parameters = setterParams
};
#endregion
#region Get the assembly reference (this also ensures the assembly gets loaded properly)
IAssemblyReference assemblyReference;
TryGetAssemblyReference(semanticProperty.Assembly, out assemblyReference);
#endregion
#region ReturnTrue:
//ReturnTrue:
_semanticPropertiesToCCIAccessorMethods[semanticProperty] = new Tuple <IMethodReference, IMethodReference>(getter, setter);
return(true);
#endregion
#region ReturnFalse:
ReturnFalse:
if (semanticProperty.Name != null)
{
ContractsPackageAccessor.Current.Logger.WriteToLog("Failed to build accessor references for: " + semanticProperty.Name.Text);
}
_semanticPropertiesToCCIAccessorMethods[semanticProperty] = new Tuple <IMethodReference, IMethodReference>(Dummy.MethodReference, Dummy.MethodReference);
return(false);
#endregion
}
public bool TryGetMethodReference(CSharpMember semanticMethod, out IMethodReference cciMethod)
{
Contract.Requires(semanticMethod == null || semanticMethod.IsConstructor || semanticMethod.IsMethod);
Contract.Ensures(!Contract.Result <bool>() || Contract.ValueAtReturn(out cciMethod) != null);
cciMethod = null;
#region Check input
if (semanticMethod == null)
{
return(false);
}
#endregion
#region Check cache
if (ContractsPackageAccessor.Current.VSOptionsPage.Caching)
{
if (_semanticMembersToCCIMethods.TryGetValue(semanticMethod, out cciMethod))
{
return((!(cciMethod is Dummy)) && cciMethod != null);
}
}
#endregion
#region Set up our working cci method
var workingCciMethod = new Microsoft.Cci.MutableCodeModel.MethodReference();
#endregion
#region Set the intern factory
workingCciMethod.InternFactory = Host.InternFactory;
#endregion
#region Get calling conventions
workingCciMethod.CallingConvention = CSharpToCCIHelper.GetCallingConventionFor(semanticMethod);
#endregion
#region Get containing type reference
ITypeReference containingType;
if (!TryGetTypeReference(semanticMethod.ContainingType, out containingType))
{
goto ReturnFalse;
}
workingCciMethod.ContainingType = containingType;
#endregion
#region Get return type reference
if (semanticMethod.IsConstructor)
{
workingCciMethod.Type = this.Host.PlatformType.SystemVoid;
}
else
{
ITypeReference returnType;
if (!TryGetTypeReference(semanticMethod.ReturnType, out returnType))
{
goto ReturnFalse;
}
workingCciMethod.Type = returnType;
}
#endregion
#region Get name
if (!semanticMethod.IsConstructor && semanticMethod.Name == null)
{
goto ReturnFalse;
}
workingCciMethod.Name = Host.NameTable.GetNameFor(semanticMethod.IsConstructor?".ctor":semanticMethod.Name.Text);
#endregion
#region Get generic param count
if (semanticMethod.TypeParameters == null)
{
workingCciMethod.GenericParameterCount = 0;
}
else
{
workingCciMethod.GenericParameterCount = (ushort)semanticMethod.TypeParameters.Count;
}
#endregion
#region Get parameter references
List <IParameterTypeInformation> cciParameters;
if (semanticMethod.Parameters == null)
{
goto ReturnFalse;
}
Contract.Assume(semanticMethod.Parameters.Count <= ushort.MaxValue, "Should be a postcondition?");
if (!TryGetParametersList(semanticMethod.Parameters, out cciParameters))
{
goto ReturnFalse;
}
workingCciMethod.Parameters = cciParameters;
#endregion
#region Get the assembly reference (this also ensures the assembly gets loaded properly)
IAssemblyReference assemblyReference;
TryGetAssemblyReference(semanticMethod.Assembly, out assemblyReference);
#endregion
cciMethod = workingCciMethod;
return(true);
#region ReturnFalse:
ReturnFalse:
cciMethod = Dummy.MethodReference;
if (ContractsPackageAccessor.Current.VSOptionsPage.Caching)
{
_semanticMembersToCCIMethods[semanticMethod] = cciMethod;
}
return(false);
#endregion
}
public bool TryGetMethodContract(CSharpMember semanticMethod, out IMethodContract methodContract)
{
Contract.Requires(semanticMethod == null || semanticMethod.IsConstructor || semanticMethod.IsMethod);
Contract.Ensures(!Contract.Result<bool>() || (Contract.ValueAtReturn(out methodContract) != null));
methodContract = null;
#region Check input
if (semanticMethod == null) {
return false;
}
#endregion
#region Try get the reference then check for contracts
IMethodReference cciMethod;
if (TryGetMethodReference(semanticMethod, out cciMethod)) {
if (TryGetMethodContract(cciMethod, out methodContract)) {
return true;
} else {
//No need, detailed logs are written at all code paths in "TryGetMethodContract"
//VSServiceProvider.Current.Logger.WriteToLog("Failed to get method contracts for: " + cciMethod.Name);
}
} else {
methodContract = null;
if (semanticMethod.Name != null)
{
VSServiceProvider.Current.Logger.WriteToLog("Failed to get CCI reference for: " + semanticMethod.Name.Text);
}
}
return false;
#endregion
}
internal RuntimeConstructorInfo(CSharpMember member)
{
this.member = member;
}
static bool TryGetIheritedFromMember(CSharpMember semanticMember, TypeDeclarationNode syntacticParentType, out CSharpMember inheritedFromMember) {
Contract.Requires(semanticMember != null);
Contract.Requires(semanticMember.IsMethod);
Contract.Ensures(!Contract.Result<bool>() ||
Contract.ValueAtReturn(out inheritedFromMember) != null &&
Contract.ValueAtReturn(out inheritedFromMember).IsMethod);
inheritedFromMember = null;
#region If member is from struct, ignore it
if (semanticMember.ContainingType.IsValueType || semanticMember.ContainingType.IsStruct) {
ContractsPackageAccessor.Current.Logger.WriteToLog("Member is struct or value type, skipping member...");
return false;
}
#endregion
#region If member is from a contract class, ignore it
//TODO: Get proper attributes from semantic model! Bug in semantic model, custom attributes don't seem to work right.
bool ignoreIt = false;
var containingType = semanticMember.ContainingType;
if (containingType.IsClass) {
if (syntacticParentType != null) {
foreach (var attributeSection in syntacticParentType.Attributes) {
foreach (var attribute in attributeSection.AttributeList) {
var attributeName = attribute.AttributeName as IdentifierNode;
if (attributeName != null) {
if (attributeName.Name.Text.Contains("ContractClassFor"))
ignoreIt = true;
}
}
}
}
}
if (ignoreIt) {
ContractsPackageAccessor.Current.Logger.WriteToLog("Member has 'ContractClassForAttribute', skipping member...");
return false;
}
#endregion
// If member is override, get base member
if (semanticMember.IsOverride) {
if (!CSharpToCCIHelper.TryGetBaseMember(semanticMember, out inheritedFromMember)) {
ContractsPackageAccessor.Current.Logger.WriteToLog("Member is an override but we can't get its base member, skipping member...");
return false; //If we can't get the base member, we don't want to keep going with this member.
}
}
else if (semanticMember.ContainingType.IsInterface || semanticMember.IsAbstract)
{
inheritedFromMember = semanticMember;
}
#region Else member implements an interface or it doesn't have inherited contracts, get interface member
else
{
if (!CSharpToCCIHelper.TryGetInterfaceMember(semanticMember, out inheritedFromMember))
{
ContractsPackageAccessor.Current.Logger.WriteToLog("Member isn't override, abstract, in an interface or an interface member, skipping member...");
return false; //If we can't get the interface member, we don't want to keep going with this member.
}
}
#endregion
return inheritedFromMember != null;
}
static bool TryGetIheritedFromMember(CSharpMember semanticMember, TypeDeclarationNode syntacticParentType, out CSharpMember inheritedFromMember)
{
Contract.Requires(semanticMember != null);
Contract.Requires(semanticMember.IsMethod);
Contract.Ensures(!Contract.Result <bool>() ||
Contract.ValueAtReturn(out inheritedFromMember) != null &&
Contract.ValueAtReturn(out inheritedFromMember).IsMethod);
inheritedFromMember = null;
#region If member is from struct, ignore it
if (semanticMember.ContainingType.IsValueType || semanticMember.ContainingType.IsStruct)
{
ContractsPackageAccessor.Current.Logger.WriteToLog("Member is struct or value type, skipping member...");
return(false);
}
#endregion
#region If member is from a contract class, ignore it
//TODO: Get proper attributes from semantic model! Bug in semantic model, custom attributes don't seem to work right.
bool ignoreIt = false;
var containingType = semanticMember.ContainingType;
if (containingType.IsClass)
{
if (syntacticParentType != null)
{
foreach (var attributeSection in syntacticParentType.Attributes)
{
foreach (var attribute in attributeSection.AttributeList)
{
var attributeName = attribute.AttributeName as IdentifierNode;
if (attributeName != null)
{
if (attributeName.Name.Text.Contains("ContractClassFor"))
{
ignoreIt = true;
}
}
}
}
}
}
if (ignoreIt)
{
ContractsPackageAccessor.Current.Logger.WriteToLog("Member has 'ContractClassForAttribute', skipping member...");
return(false);
}
#endregion
// If member is override, get base member
if (semanticMember.IsOverride)
{
if (!CSharpToCCIHelper.TryGetBaseMember(semanticMember, out inheritedFromMember))
{
ContractsPackageAccessor.Current.Logger.WriteToLog("Member is an override but we can't get its base member, skipping member...");
return(false); //If we can't get the base member, we don't want to keep going with this member.
}
}
else if (semanticMember.ContainingType.IsInterface || semanticMember.IsAbstract)
{
inheritedFromMember = semanticMember;
}
#region Else member implements an interface or it doesn't have inherited contracts, get interface member
else
{
if (!CSharpToCCIHelper.TryGetInterfaceMember(semanticMember, out inheritedFromMember))
{
ContractsPackageAccessor.Current.Logger.WriteToLog("Member isn't override, abstract, in an interface or an interface member, skipping member...");
return(false); //If we can't get the interface member, we don't want to keep going with this member.
}
}
#endregion
return(inheritedFromMember != null);
}
private string GetFormattedContracts(CSharpMember semanticMember)
{
Contract.Requires(semanticMember != null);
Contract.Requires(semanticMember.IsMethod || semanticMember.IsConstructor || semanticMember.IsProperty || semanticMember.IsIndexer);
if (semanticMember.IsProperty || semanticMember.IsIndexer)
{
IMethodContract setter, getter;
if (!((ContractsProvider)_textViewTracker.ProjectTracker.ContractsProvider).TryGetPropertyContract(semanticMember, out getter, out setter))
{
return null;
}
return IntellisenseContractsHelper.FormatPropertyContracts(getter, setter);
}
//Can we get our contracts?
IMethodContract methodContracts;
if (!((ContractsProvider)_textViewTracker.ProjectTracker.ContractsProvider).TryGetMethodContract(semanticMember, out methodContracts))
return null;
//Can we get our formatted contracts?
return IntellisenseContractsHelper.FormatContracts(methodContracts);
}
public static new bool IsSupportedMemberType(CSharpMember member)
{
return(MatchingMemberCollector.IsSupportedMemberType(member));
}
internal RuntimePropertyInfo(CSharpMember member)
{
this.member = member;
}
public static new bool IsSupportedMemberType(CSharpMember member)
{
return MatchingMemberCollector.IsSupportedMemberType(member);
}
internal RuntimeMethodInfo(CSharpMember member)
{
this.member = member;
}
public bool TryGetPropertyContract(CSharpMember semanticMember, out IMethodContract getterContract, out IMethodContract setterContract)
{
Contract.Requires(semanticMember == null || semanticMember.IsProperty || semanticMember.IsIndexer);
getterContract = null;
setterContract = null;
#region Check input
if (semanticMember == null)
{
return false;
}
#endregion
IMethodReference getter, setter;
if (!TryGetPropertyAccessorReferences(semanticMember, out getter, out setter)) { return false; }
var success = false;
if (getter != null)
{
success |= TryGetMethodContract(getter, out getterContract);
}
if (setter != null)
{
success |= TryGetMethodContract(setter, out setterContract);
}
return success;
}
