public void WalkTypeInfosInEmptyLibrary()
{
MockTypeLib typeLib = new MockTypeLib();
ComDependencyWalker walker = new ComDependencyWalker(new MarshalReleaseComObject(MockReleaseComObject));
walker.AnalyzeTypeLibrary(typeLib);
Assert.Equal(0, walker.GetDependencies().GetLength(0));
typeLib.AssertAllHandlesReleased();
}
private TYPELIBATTR[] RunDependencyWalker(MockTypeLib mainTypeLib, MockTypeLib dependencyTypeLib, bool dependencyShouldBePresent)
{
ComDependencyWalker walker = new ComDependencyWalker(new MarshalReleaseComObject(MockReleaseComObject));
walker.AnalyzeTypeLibrary(mainTypeLib);
TYPELIBATTR[] dependencies = walker.GetDependencies();
// types from the main type library should be in the dependency list
AssertDependenciesContainTypeLib(dependencies, mainTypeLib, true);
AssertDependenciesContainTypeLib(dependencies, dependencyTypeLib, dependencyShouldBePresent);
mainTypeLib.AssertAllHandlesReleased();
dependencyTypeLib.AssertAllHandlesReleased();
return dependencies;
}
private List<string> ScanAndResolveAllDependencies(ComDependencyWalker dependencyWalker, ComReferenceInfo reference)
{
dependencyWalker.ClearDependencyList();
base.Log.LogMessageFromResources(MessageImportance.Low, "ResolveComReference.ScanningDependencies", new object[] { reference.SourceItemSpec });
dependencyWalker.AnalyzeTypeLibrary(reference.typeLibPointer);
foreach (Exception exception in dependencyWalker.EncounteredProblems)
{
base.Log.LogWarningWithCodeFromResources("ResolveComReference.FailedToScanDependencies", new object[] { reference.SourceItemSpec, exception.Message });
}
dependencyWalker.EncounteredProblems.Clear();
HashSet<string> source = new HashSet<string>();
foreach (System.Runtime.InteropServices.ComTypes.TYPELIBATTR typelibattr in dependencyWalker.GetDependencies())
{
if (!ComReference.AreTypeLibAttrEqual(typelibattr, reference.attr))
{
ComReferenceInfo info;
if (this.IsExistingProjectReference(typelibattr, null, out info))
{
ITaskItem item;
dependencyWalker.ClearAnalyzedTypeCache();
if (this.ResolveReference(dependencyWalker, info, this.WrapperOutputDirectory, out item))
{
source.Add(item.ItemSpec);
foreach (string str in info.dependentWrapperPaths)
{
source.Add(str);
}
}
}
else
{
ComReferenceWrapperInfo info2;
base.Log.LogMessageFromResources(MessageImportance.Low, "ResolveComReference.ResolvingDependency", new object[] { typelibattr.guid, typelibattr.wMajorVerNum, typelibattr.wMinorVerNum });
((IComReferenceResolver) this).ResolveComClassicReference(typelibattr, this.WrapperOutputDirectory, null, null, out info2);
base.Log.LogMessageFromResources(MessageImportance.Low, "ResolveComReference.ResolvedDependentComReference", new object[] { typelibattr.guid, typelibattr.wMajorVerNum, typelibattr.wMinorVerNum, info2.path });
source.Add(info2.path);
}
}
}
return source.ToList<string>();
}
private bool ResolveReferenceAndAddToList(ComDependencyWalker dependencyWalker, ComReferenceInfo projectRefInfo, ArrayList resolvedReferenceList, ArrayList moduleList)
{
ITaskItem item;
if (!this.ResolveReference(dependencyWalker, projectRefInfo, this.WrapperOutputDirectory, out item))
{
return false;
}
resolvedReferenceList.Add(item);
bool metadataFound = false;
bool flag2 = MetadataConversionUtilities.TryConvertItemMetadataToBool(projectRefInfo.taskItem, "Isolated", out metadataFound);
if (metadataFound && flag2)
{
string typeLibPath = projectRefInfo.typeLibPath;
if (typeLibPath == null)
{
return false;
}
ITaskItem item2 = new TaskItem(typeLibPath);
item2.SetMetadata("Name", projectRefInfo.taskItem.ItemSpec);
moduleList.Add(item2);
}
return true;
}
internal bool ResolveReference(ComDependencyWalker dependencyWalker, ComReferenceInfo referenceInfo, string outputDirectory, out ITaskItem referencePathItem)
{
if (referenceInfo.referencePathItem == null)
{
ComReferenceWrapperInfo info;
base.Log.LogMessageFromResources(MessageImportance.Low, "ResolveComReference.Resolving", new object[] { referenceInfo.taskItem.ItemSpec, referenceInfo.taskItem.GetMetadata("WrapperTool") });
List<string> list = this.ScanAndResolveAllDependencies(dependencyWalker, referenceInfo);
referenceInfo.dependentWrapperPaths = list;
referencePathItem = new TaskItem();
referenceInfo.referencePathItem = referencePathItem;
if (this.ResolveComClassicReference(referenceInfo, outputDirectory, referenceInfo.taskItem.GetMetadata("WrapperTool"), referenceInfo.taskItem.ItemSpec, true, referenceInfo.dependentWrapperPaths, out info))
{
referencePathItem.ItemSpec = info.path;
referenceInfo.taskItem.CopyMetadataTo(referencePathItem);
string fullName = AssemblyName.GetAssemblyName(info.path).FullName;
referencePathItem.SetMetadata("FusionName", fullName);
base.Log.LogMessageFromResources(MessageImportance.Low, "ResolveComReference.ResolvedReference", new object[] { referenceInfo.taskItem.ItemSpec, info.path });
return true;
}
base.Log.LogWarningWithCodeFromResources("ResolveComReference.CannotFindWrapperForTypeLib", new object[] { referenceInfo.taskItem.ItemSpec });
return false;
}
bool flag = !string.IsNullOrEmpty(referenceInfo.referencePathItem.ItemSpec);
referencePathItem = referenceInfo.referencePathItem;
return flag;
}
public override bool Execute()
{
bool flag2;
if (!this.VerifyAndInitializeInputs())
{
return false;
}
if (!this.ComputePathToAxImp() || !this.ComputePathToTlbImp())
{
return false;
}
this.allProjectRefs = new List<ComReferenceInfo>();
this.allDependencyRefs = new List<ComReferenceInfo>();
this.timestampCache = (ResolveComReferenceCache) StateFileBase.DeserializeCache(this.StateFile, base.Log, typeof(ResolveComReferenceCache));
if ((this.timestampCache == null) || ((this.timestampCache != null) && !this.timestampCache.ToolPathsMatchCachePaths(this.tlbimpPath, this.aximpPath)))
{
base.Log.LogMessageFromResources(MessageImportance.Low, "ResolveComReference.NotUsingCacheFile", new object[] { (this.StateFile == null) ? string.Empty : this.StateFile });
this.timestampCache = new ResolveComReferenceCache(this.tlbimpPath, this.aximpPath);
}
else
{
base.Log.LogMessageFromResources(MessageImportance.Low, "ResolveComReference.UsingCacheFile", new object[] { (this.StateFile == null) ? string.Empty : this.StateFile });
}
try
{
this.ConvertAttrReferencesToComReferenceInfo(this.allProjectRefs, this.TypeLibNames);
this.ConvertFileReferencesToComReferenceInfo(this.allProjectRefs, this.TypeLibFiles);
this.AddMissingTlbReferences();
this.CheckForConflictingReferences();
this.SetFrameworkVersionFromString(this.projectTargetFrameworkAsString);
ArrayList moduleList = new ArrayList();
ArrayList resolvedReferenceList = new ArrayList();
ComDependencyWalker dependencyWalker = new ComDependencyWalker(new MarshalReleaseComObject(Marshal.ReleaseComObject));
bool flag = true;
for (int i = 0; i < 4; i++)
{
foreach (ComReferenceInfo info in this.allProjectRefs)
{
string metadata = info.taskItem.GetMetadata("WrapperTool");
if ((((i == 0) && ComReferenceTypes.IsPia(metadata)) || ((i == 1) && ComReferenceTypes.IsTlbImp(metadata))) || (((i == 2) && ComReferenceTypes.IsPiaOrTlbImp(metadata)) || ((i == 3) && ComReferenceTypes.IsAxImp(metadata))))
{
try
{
if (!this.ResolveReferenceAndAddToList(dependencyWalker, info, resolvedReferenceList, moduleList))
{
flag = false;
}
}
catch (ComReferenceResolutionException)
{
}
catch (StrongNameException)
{
return false;
}
catch (FileLoadException exception)
{
if (!this.DelaySign)
{
throw;
}
base.Log.LogErrorWithCodeFromResources(null, info.SourceItemSpec, 0, 0, 0, 0, "ResolveComReference.LoadingDelaySignedAssemblyWithStrongNameVerificationEnabled", new object[] { exception.Message });
return false;
}
catch (ArgumentException exception2)
{
base.Log.LogErrorWithCodeFromResources("General.InvalidArgument", new object[] { exception2.Message });
return false;
}
catch (SystemException exception3)
{
base.Log.LogErrorWithCodeFromResources("ResolveComReference.FailedToResolveComReference", new object[] { info.attr.guid, info.attr.wMajorVerNum, info.attr.wMinorVerNum, exception3.Message });
}
}
}
}
this.SetCopyLocalToFalseOnGacOrNoPIAAssemblies(resolvedReferenceList, GlobalAssemblyCache.GetGacPath());
this.ResolvedModules = (ITaskItem[]) moduleList.ToArray(typeof(ITaskItem));
this.ResolvedFiles = (ITaskItem[]) resolvedReferenceList.ToArray(typeof(ITaskItem));
flag2 = flag && !base.Log.HasLoggedErrors;
}
finally
{
if ((this.timestampCache != null) && this.timestampCache.Dirty)
{
this.timestampCache.SerializeCache(this.StateFile, base.Log);
}
this.Cleanup();
}
return flag2;
}
private void RunDependencyWalkerFaultInjection(MockTypeLibrariesFailurePoints failurePoint, MockTypeLib mainTypeLib, MockTypeLib dependencyTypeLibGood1, MockTypeLib dependencyTypeLibBad1, MockTypeLib dependencyTypeLibGood2, MockTypeLib dependencyTypeLibBad2)
{
ComDependencyWalker walker = new ComDependencyWalker(new MarshalReleaseComObject(MockReleaseComObject));
walker.AnalyzeTypeLibrary(mainTypeLib);
// Did the current failure point get hit for this test? If not then no point in checking anything
// The previous test (FaultInjectionMainLib) ensures that all defined failure points actually
// cause some sort of trouble
if (walker.EncounteredProblems.Count > 0)
{
TYPELIBATTR[] dependencies = walker.GetDependencies();
AssertDependenciesContainTypeLib("Test failed for failure point " + failurePoint.ToString(),
dependencies, mainTypeLib, true);
AssertDependenciesContainTypeLib("Test failed for failure point " + failurePoint.ToString(),
dependencies, dependencyTypeLibGood1, true);
AssertDependenciesContainTypeLib("Test failed for failure point " + failurePoint.ToString(),
dependencies, dependencyTypeLibGood2, true);
AssertDependenciesContainTypeLib("Test failed for failure point " + failurePoint.ToString(),
dependencies, dependencyTypeLibBad1, false);
AssertDependenciesContainTypeLib("Test failed for failure point " + failurePoint.ToString(),
dependencies, dependencyTypeLibBad2, false);
}
mainTypeLib.AssertAllHandlesReleased();
dependencyTypeLibGood1.AssertAllHandlesReleased();
dependencyTypeLibGood2.AssertAllHandlesReleased();
dependencyTypeLibBad1.AssertAllHandlesReleased();
dependencyTypeLibBad2.AssertAllHandlesReleased();
}
public void FullDependenciesWithIncrementalAnalysis()
{
MockTypeLib mainTypeLib1, mainTypeLib2, mainTypeLib3, dependencyTypeLib1, dependencyTypeLib2, dependencyTypeLib3;
CreateTwoTypeLibs(out mainTypeLib1, out dependencyTypeLib1);
CreateTwoTypeLibs(out mainTypeLib2, out dependencyTypeLib2);
CreateTwoTypeLibs(out mainTypeLib3, out dependencyTypeLib3);
mainTypeLib1.ContainedTypeInfos[0].DefinesVariable(dependencyTypeLib1.ContainedTypeInfos[0]);
mainTypeLib2.ContainedTypeInfos[0].DefinesVariable(dependencyTypeLib1.ContainedTypeInfos[0]);
mainTypeLib2.ContainedTypeInfos[0].DefinesVariable(dependencyTypeLib2.ContainedTypeInfos[0]);
mainTypeLib3.ContainedTypeInfos[0].DefinesVariable(dependencyTypeLib1.ContainedTypeInfos[0]);
mainTypeLib3.ContainedTypeInfos[0].DefinesVariable(dependencyTypeLib3.ContainedTypeInfos[0]);
ComDependencyWalker walker = new ComDependencyWalker(MockReleaseComObject);
walker.AnalyzeTypeLibrary(mainTypeLib1);
TYPELIBATTR[] dependencies = walker.GetDependencies();
ICollection<string> analyzedTypes = walker.GetAnalyzedTypeNames();
AssertDependenciesContainTypeLib(dependencies, dependencyTypeLib1, true);
AssertDependenciesContainTypeLib(dependencies, dependencyTypeLib2, false);
AssertDependenciesContainTypeLib(dependencies, dependencyTypeLib3, false);
Assert.Equal(2, analyzedTypes.Count);
walker.ClearDependencyList();
walker.AnalyzeTypeLibrary(mainTypeLib2);
dependencies = walker.GetDependencies();
analyzedTypes = walker.GetAnalyzedTypeNames();
AssertDependenciesContainTypeLib(dependencies, dependencyTypeLib1, true);
AssertDependenciesContainTypeLib(dependencies, dependencyTypeLib2, true);
AssertDependenciesContainTypeLib(dependencies, dependencyTypeLib3, false);
Assert.Equal(4, analyzedTypes.Count);
walker.ClearDependencyList();
walker.AnalyzeTypeLibrary(mainTypeLib3);
dependencies = walker.GetDependencies();
analyzedTypes = walker.GetAnalyzedTypeNames();
AssertDependenciesContainTypeLib(dependencies, dependencyTypeLib1, true);
AssertDependenciesContainTypeLib(dependencies, dependencyTypeLib2, false);
AssertDependenciesContainTypeLib(dependencies, dependencyTypeLib3, true);
Assert.Equal(6, analyzedTypes.Count);
}
public void FaultInjectionMainLib()
{
// The primary test here is that we don't throw, which can't be explicitly expressed in NUnit...
// other asserts are secondary
foreach (MockTypeLibrariesFailurePoints failurePoint in Enum.GetValues(typeof(MockTypeLibrariesFailurePoints)))
{
MockTypeLib mainTypeLib = new MockTypeLib();
mainTypeLib.AddTypeInfo(new MockTypeInfo());
// Make it the StdOle lib to exercise the ITypeInfo.GetDocumentation failure point
MockTypeLib dependencyTypeLib = new MockTypeLib(NativeMethods.IID_StdOle);
dependencyTypeLib.AddTypeInfo(new MockTypeInfo());
COMException failureException = new COMException("unhandled exception in " + failurePoint.ToString());
mainTypeLib.InjectFailure(failurePoint, failureException);
dependencyTypeLib.InjectFailure(failurePoint, failureException);
mainTypeLib.ContainedTypeInfos[0].ImplementsInterface(dependencyTypeLib.ContainedTypeInfos[0]);
mainTypeLib.ContainedTypeInfos[0].DefinesVariable(dependencyTypeLib.ContainedTypeInfos[0]);
mainTypeLib.ContainedTypeInfos[0].DefinesFunction(
new MockTypeInfo[] { dependencyTypeLib.ContainedTypeInfos[0] }, dependencyTypeLib.ContainedTypeInfos[0]);
ComDependencyWalker walker = new ComDependencyWalker(new MarshalReleaseComObject(MockReleaseComObject));
walker.AnalyzeTypeLibrary(mainTypeLib);
Assert.Equal(1, walker.EncounteredProblems.Count); // "Test failed for failure point " + failurePoint.ToString()
Assert.Equal(failureException, walker.EncounteredProblems[0]); // "Test failed for failure point " + failurePoint.ToString()
mainTypeLib.AssertAllHandlesReleased();
dependencyTypeLib.AssertAllHandlesReleased();
}
}
/*
* Method: ResolveReference
*
* Helper COM resolution method. Creates an appropriate helper class for the given tool and calls
* the Resolve method on it.
*/
internal bool ResolveReference(ComDependencyWalker dependencyWalker, ComReferenceInfo referenceInfo, string outputDirectory, out ITaskItem referencePathItem)
{
if (referenceInfo.referencePathItem == null)
{
if (!Silent)
{
Log.LogMessageFromResources(MessageImportance.Low, "ResolveComReference.Resolving", referenceInfo.taskItem.ItemSpec, referenceInfo.taskItem.GetMetadata(ComReferenceItemMetadataNames.wrapperTool));
}
List<string> dependencyPaths = ScanAndResolveAllDependencies(dependencyWalker, referenceInfo);
referenceInfo.dependentWrapperPaths = dependencyPaths;
referencePathItem = new TaskItem();
referenceInfo.referencePathItem = referencePathItem;
ComReferenceWrapperInfo wrapperInfo;
if (ResolveComClassicReference(referenceInfo, outputDirectory,
referenceInfo.taskItem.GetMetadata(ComReferenceItemMetadataNames.wrapperTool),
referenceInfo.taskItem.ItemSpec, true, referenceInfo.dependentWrapperPaths, out wrapperInfo))
{
referencePathItem.ItemSpec = wrapperInfo.path;
referenceInfo.taskItem.CopyMetadataTo(referencePathItem);
string fusionName = AssemblyName.GetAssemblyName(wrapperInfo.path).FullName;
referencePathItem.SetMetadata(ItemMetadataNames.fusionName, fusionName);
if (!Silent)
{
Log.LogMessageFromResources(MessageImportance.Low, "ResolveComReference.ResolvedReference", referenceInfo.taskItem.ItemSpec, wrapperInfo.path);
}
return true;
}
if (!Silent)
{
Log.LogWarningWithCodeFromResources("ResolveComReference.CannotFindWrapperForTypeLib", referenceInfo.taskItem.ItemSpec);
}
return false;
}
else
{
bool successfullyResolved = !String.IsNullOrEmpty(referenceInfo.referencePathItem.ItemSpec);
referencePathItem = referenceInfo.referencePathItem;
return successfullyResolved;
}
}
/// <summary>
/// Resolves the COM reference, and adds it to the appropriate item list.
/// </summary>
/// <param name="projectRefInfo"></param>
/// <param name="resolvedReferenceList"></param>
/// <param name="moduleList"></param>
/// <returns></returns>
private bool ResolveReferenceAndAddToList
(
ComDependencyWalker dependencyWalker,
ComReferenceInfo projectRefInfo,
ArrayList resolvedReferenceList,
ArrayList moduleList
)
{
ITaskItem referencePath;
if (ResolveReference(dependencyWalker, projectRefInfo, WrapperOutputDirectory, out referencePath))
{
resolvedReferenceList.Add(referencePath);
bool metadataFound = false;
bool isolated = MetadataConversionUtilities.TryConvertItemMetadataToBool(projectRefInfo.taskItem, "Isolated", out metadataFound);
if (metadataFound && isolated)
{
string modulePath = projectRefInfo.strippedTypeLibPath;
if (modulePath != null)
{
ITaskItem moduleItem = new TaskItem(modulePath);
moduleItem.SetMetadata("Name", projectRefInfo.taskItem.ItemSpec);
moduleList.Add(moduleItem);
}
else
{
return false;
}
}
}
else
{
return false;
}
return true;
}
/// <summary>
/// Task entry point.
/// </summary>
/// <returns></returns>
public override bool Execute()
{
if (!VerifyAndInitializeInputs())
{
return false;
}
if (!ComputePathToAxImp() || !ComputePathToTlbImp())
{
// unable to compute the path to tlbimp.exe, aximp.exe, or both and that is necessary to
// continue forward, so return now.
return false;
}
allProjectRefs = new List<ComReferenceInfo>();
allDependencyRefs = new List<ComReferenceInfo>();
_timestampCache = (ResolveComReferenceCache)StateFileBase.DeserializeCache(StateFile, Log, typeof(ResolveComReferenceCache));
if (_timestampCache == null || (_timestampCache != null && !_timestampCache.ToolPathsMatchCachePaths(_tlbimpPath, _aximpPath)))
{
if (!Silent)
{
Log.LogMessageFromResources(MessageImportance.Low, "ResolveComReference.NotUsingCacheFile", StateFile == null ? String.Empty : StateFile);
}
_timestampCache = new ResolveComReferenceCache(_tlbimpPath, _aximpPath);
}
else if (!Silent)
{
Log.LogMessageFromResources(MessageImportance.Low, "ResolveComReference.UsingCacheFile", StateFile == null ? String.Empty : StateFile);
}
try
{
ConvertAttrReferencesToComReferenceInfo(allProjectRefs, TypeLibNames);
ConvertFileReferencesToComReferenceInfo(allProjectRefs, TypeLibFiles);
// add missing tlbimp references for aximp ones
AddMissingTlbReferences();
// see if we have any typelib name clashes. Ignore the return value - we now remove the conflicting refs
// and continue (first one wins)
CheckForConflictingReferences();
SetFrameworkVersionFromString(_projectTargetFrameworkAsString);
// Process each task item. If one of them fails we still process the rest of them, but
// remember that the task should return failure.
// DESIGN CHANGE: we no longer fail the task when one or more references fail to resolve.
// Unless we experience a catastrophic failure, we'll log warnings for those refs and proceed
// (and return success)
ArrayList moduleList = new ArrayList();
ArrayList resolvedReferenceList = new ArrayList();
ComDependencyWalker dependencyWalker = new ComDependencyWalker(Marshal.ReleaseComObject);
bool allReferencesResolvedSuccessfully = true;
for (int pass = 0; pass < 4; pass++)
{
foreach (ComReferenceInfo projectRefInfo in allProjectRefs)
{
string wrapperType = projectRefInfo.taskItem.GetMetadata(ComReferenceItemMetadataNames.wrapperTool);
// first resolve all PIA refs, then regular tlb refs and finally ActiveX refs
if ((pass == 0 && ComReferenceTypes.IsPia(wrapperType)) ||
(pass == 1 && ComReferenceTypes.IsTlbImp(wrapperType)) ||
(pass == 2 && ComReferenceTypes.IsPiaOrTlbImp(wrapperType)) ||
(pass == 3 && ComReferenceTypes.IsAxImp(wrapperType)))
{
try
{
if (!this.ResolveReferenceAndAddToList(dependencyWalker, projectRefInfo, resolvedReferenceList, moduleList))
{
allReferencesResolvedSuccessfully = false;
}
}
catch (ComReferenceResolutionException)
{
// problem resolving this reference? continue so that we can display all error messages
}
catch (StrongNameException)
{
// key extraction problem? No point in continuing, since all wrappers will hit the same problem.
// error message has already been logged
return false;
}
catch (FileLoadException ex)
{
// This exception is thrown when we try to load a delay signed assembly without disabling
// strong name verification first. So print a nice information if we're generating
// delay signed wrappers, otherwise rethrow, since it's an unexpected exception.
if (DelaySign)
{
Log.LogErrorWithCodeFromResources(null, projectRefInfo.SourceItemSpec, 0, 0, 0, 0, "ResolveComReference.LoadingDelaySignedAssemblyWithStrongNameVerificationEnabled", ex.Message);
// no point in printing the same thing multiple times...
return false;
}
else
{
Debug.Assert(false, "Unexpected exception in ResolveComReference.Execute. " +
"Please log a MSBuild bug specifying the steps to reproduce the problem.");
throw;
}
}
catch (ArgumentException ex)
{
// This exception is thrown when we try to convert some of the Metadata from the project
// file and the conversion fails. Most likely, the user needs to correct a type in the
// project file.
Log.LogErrorWithCodeFromResources("General.InvalidArgument", ex.Message);
return false;
}
catch (SystemException ex)
{
Log.LogErrorWithCodeFromResources("ResolveComReference.FailedToResolveComReference",
projectRefInfo.attr.guid, projectRefInfo.attr.wMajorVerNum, projectRefInfo.attr.wMinorVerNum,
ex.Message);
}
}
}
}
SetCopyLocalToFalseOnGacOrNoPIAAssemblies(resolvedReferenceList, GlobalAssemblyCache.GetGacPath());
ResolvedModules = (ITaskItem[])moduleList.ToArray(typeof(ITaskItem));
ResolvedFiles = (ITaskItem[])resolvedReferenceList.ToArray(typeof(ITaskItem));
// The Logs from AxImp and TlbImp aren't part of our log, but if the task failed, it will return false from
// GenerateWrapper, which should get passed all the way back up here.
return allReferencesResolvedSuccessfully && !Log.HasLoggedErrors;
}
finally
{
if ((_timestampCache != null) && _timestampCache.Dirty)
{
_timestampCache.SerializeCache(StateFile, Log);
}
Cleanup();
}
}
/// <summary>
/// Scan all the dependencies of the main project references and preresolve them
/// so that when we get asked about a previously unknown dependency in the form of a .NET assembly
/// we know what to do with it.
/// </summary>
private List<string> ScanAndResolveAllDependencies(ComDependencyWalker dependencyWalker, ComReferenceInfo reference)
{
dependencyWalker.ClearDependencyList();
if (!Silent)
{
Log.LogMessageFromResources(MessageImportance.Low, "ResolveComReference.ScanningDependencies", reference.SourceItemSpec);
}
dependencyWalker.AnalyzeTypeLibrary(reference.typeLibPointer);
if (!Silent)
{
foreach (Exception ex in dependencyWalker.EncounteredProblems)
{
// A failure to resolve a reference due to something possibly being missing from disk is not
// an error; the user may not be actually consuming types from it
Log.LogWarningWithCodeFromResources("ResolveComReference.FailedToScanDependencies",
reference.SourceItemSpec, ex.Message);
}
}
dependencyWalker.EncounteredProblems.Clear();
HashSet<string> dependentPaths = new HashSet<string>();
TYPELIBATTR[] dependentAttrs = dependencyWalker.GetDependencies();
foreach (TYPELIBATTR dependencyTypeLibAttr in dependentAttrs)
{
// We don't need to even try to resolve if the dependency reference is ourselves.
if (!ComReference.AreTypeLibAttrEqual(dependencyTypeLibAttr, reference.attr))
{
ComReferenceInfo existingReference;
if (IsExistingProjectReference(dependencyTypeLibAttr, null, out existingReference))
{
ITaskItem resolvedItem;
// If we're resolving another project reference, empty out the type cache -- if the dependencies are buried,
// caching the analyzed types can make it so that we don't recognize our dependencies' dependencies.
dependencyWalker.ClearAnalyzedTypeCache();
if (ResolveReference(dependencyWalker, existingReference, WrapperOutputDirectory, out resolvedItem))
{
// Add the resolved dependency
dependentPaths.Add(resolvedItem.ItemSpec);
// and anything it depends on
foreach (string dependentPath in existingReference.dependentWrapperPaths)
{
dependentPaths.Add(dependentPath);
}
}
}
else
{
if (!Silent)
{
Log.LogMessageFromResources(MessageImportance.Low, "ResolveComReference.ResolvingDependency",
dependencyTypeLibAttr.guid, dependencyTypeLibAttr.wMajorVerNum, dependencyTypeLibAttr.wMinorVerNum);
}
ComReferenceWrapperInfo wrapperInfo;
((IComReferenceResolver)this).ResolveComClassicReference(dependencyTypeLibAttr, WrapperOutputDirectory,
null /* unknown wrapper type */, null /* unknown name */, out wrapperInfo);
if (!Silent)
{
Log.LogMessageFromResources(MessageImportance.Low, "ResolveComReference.ResolvedDependentComReference",
dependencyTypeLibAttr.guid, dependencyTypeLibAttr.wMajorVerNum, dependencyTypeLibAttr.wMinorVerNum,
wrapperInfo.path);
}
dependentPaths.Add(wrapperInfo.path);
}
}
}
return dependentPaths.ToList<string>();
}