Resolve assemblies referenced by T4 templates that are not referenced by the project.

src/AddIns/Misc/TextTemplating/Project/Src/IAssemblyParserService.cs

@@ -0,0 +1,13 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.SharpDevelop.Project;
+
+namespace ICSharpCode.TextTemplating
+{
+	public interface IAssemblyParserService
+	{
+		IReflectionProjectContent GetReflectionProjectContentForReference(ReferenceProjectItem item);
+	}
+}

src/AddIns/Misc/TextTemplating/Project/Src/IReflectionProjectContent.cs

@@ -0,0 +1,12 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+
+namespace ICSharpCode.TextTemplating
+{
+	public interface IReflectionProjectContent
+	{
+		string AssemblyLocation { get; }
+	}
+}

src/AddIns/Misc/TextTemplating/Project/Src/TextTemplatingAssemblyParserService.cs

@@ -0,0 +1,19 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.SharpDevelop;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Project;
+
+namespace ICSharpCode.TextTemplating
+{
+	public class TextTemplatingAssemblyParserService : IAssemblyParserService
+	{
+		public IReflectionProjectContent GetReflectionProjectContentForReference(ReferenceProjectItem item)
+		{
+			IProjectContent projectContent = AssemblyParserService.GetProjectContentForReference(item);
+			return new TextTemplatingReflectionProjectContent(projectContent);
+		}
+	}
+}

src/AddIns/Misc/TextTemplating/Project/Src/TextTemplatingAssemblyResolver.cs

@@ -9,25 +9,66 @@ namespace ICSharpCode.TextTemplating
 	public class TextTemplatingAssemblyResolver : ITextTemplatingAssemblyResolver
 	{
 		IProject project;
+		IAssemblyParserService assemblyParserService;
 		
-		public TextTemplatingAssemblyResolver(IProject project)
+		public TextTemplatingAssemblyResolver(
+			IProject project,
+			IAssemblyParserService assemblyParserService)
 		{
 			this.project = project;
+			this.assemblyParserService = assemblyParserService;
+		}
+		
+		public TextTemplatingAssemblyResolver(IProject project)
+			: this(project, new TextTemplatingAssemblyParserService())
+		{
 		}
 		
 		public string Resolve(string assemblyReference)
+		{
+			string resolvedAssemblyFileName = ResolveAssemblyFromProject(assemblyReference);
+			if (resolvedAssemblyFileName == null) {
+				resolvedAssemblyFileName = ResolveAssemblyFromGac(assemblyReference);
+			}
+			if (resolvedAssemblyFileName != null) {
+				return resolvedAssemblyFileName;
+			}
+			return assemblyReference;
+		}
+		
+		string ResolveAssemblyFromProject(string assemblyReference)
 		{
 			foreach (ReferenceProjectItem refProjectItem in project.GetItemsOfType(ItemType.Reference)) {
 				if (IsMatch(refProjectItem, assemblyReference)) {
 					return refProjectItem.FileName;
 				}
 			}
-			return assemblyReference;
+			return null;
 		}
 		
 		bool IsMatch(ReferenceProjectItem refProjectItem, string assemblyReference)
 		{
 			return String.Equals(refProjectItem.Include, assemblyReference, StringComparison.InvariantCultureIgnoreCase);
 		}
+		
+		string ResolveAssemblyFromGac(string assemblyReference)
+		{
+			IReflectionProjectContent projectContent = GetProjectContent(assemblyReference);
+			if (projectContent != null) {
+				return projectContent.AssemblyLocation;
+			}
+			return null;
+		}
+		
+		IReflectionProjectContent GetProjectContent(string assemblyReference)
+		{
+			var reference = new ReferenceProjectItem(project, assemblyReference);
+			return GetProjectContent(reference);
+		}
+		
+		IReflectionProjectContent GetProjectContent(ReferenceProjectItem refProjectItem)
+		{
+			return assemblyParserService.GetReflectionProjectContentForReference(refProjectItem);
+		}
 	}
 }

src/AddIns/Misc/TextTemplating/Project/Src/TextTemplatingReflectionProjectContent.cs

@@ -0,0 +1,25 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.SharpDevelop.Dom;
+
+namespace ICSharpCode.TextTemplating
+{
+	public class TextTemplatingReflectionProjectContent : IReflectionProjectContent
+	{
+		public TextTemplatingReflectionProjectContent(IProjectContent projectContent)
+			: this(projectContent as ReflectionProjectContent)
+		{
+		}
+		
+		TextTemplatingReflectionProjectContent(ReflectionProjectContent projectContent)
+		{
+			if (projectContent != null) {
+				AssemblyLocation = projectContent.AssemblyLocation;
+			}
+		}
+		
+		public string AssemblyLocation { get; private set; }
+	}
+}

src/AddIns/Misc/TextTemplating/Project/TextTemplating.csproj

@@ -51,6 +51,8 @@
       <Link>Configuration\GlobalAssemblyInfo.cs</Link>
     </Compile>
     <Compile Include="Src\CompilerErrorTask.cs" />
+    <Compile Include="Src\IAssemblyParserService.cs" />
+    <Compile Include="Src\IReflectionProjectContent.cs" />
     <Compile Include="Src\ITextTemplatingAppDomain.cs" />
     <Compile Include="Src\ITextTemplatingAppDomainFactory.cs" />
     <Compile Include="Src\ITextTemplatingAssemblyResolver.cs" />
@@ -62,6 +64,7 @@
     <Compile Include="Src\TemplatingHostProcessTemplateError.cs" />
     <Compile Include="Src\TextTemplatingAppDomain.cs" />
     <Compile Include="Src\TextTemplatingAppDomainFactory.cs" />
+    <Compile Include="Src\TextTemplatingAssemblyParserService.cs" />
     <Compile Include="Src\TextTemplatingAssemblyResolver.cs" />
     <Compile Include="Src\TextTemplatingCustomTool.cs" />
     <Compile Include="Src\TextTemplatingCustomToolContext.cs" />
@@ -72,6 +75,7 @@
     <Compile Include="Src\TextTemplatingFilePreprocessorCustomTool.cs" />
     <Compile Include="Src\TextTemplatingFileProcessor.cs" />
     <Compile Include="Src\TextTemplatingHost.cs" />
+    <Compile Include="Src\TextTemplatingReflectionProjectContent.cs" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Resources\TextTemplating.xshd" />

src/AddIns/Misc/TextTemplating/Test/Helpers/FakeAssemblyParserService.cs

@@ -0,0 +1,21 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.SharpDevelop.Project;
+using ICSharpCode.TextTemplating;
+
+namespace TextTemplating.Tests.Helpers
+{
+	public class FakeAssemblyParserService : IAssemblyParserService
+	{
+		public FakeReflectionProjectContent FakeReflectionProjectContent = new FakeReflectionProjectContent();
+		public ReferenceProjectItem ItemPassedToGetReflectionProjectContentForReference;
+		
+		public IReflectionProjectContent GetReflectionProjectContentForReference(ReferenceProjectItem item)
+		{
+			ItemPassedToGetReflectionProjectContentForReference = item;
+			return FakeReflectionProjectContent;
+		}
+	}
+}

src/AddIns/Misc/TextTemplating/Test/Helpers/FakeReflectionProjectContent.cs

@@ -0,0 +1,13 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.TextTemplating;
+
+namespace TextTemplating.Tests.Helpers
+{
+	public class FakeReflectionProjectContent : IReflectionProjectContent
+	{
+		public string AssemblyLocation { get; set; }
+	}
+}

src/AddIns/Misc/TextTemplating/Test/Src/TextTemplatingAssemblyResolverTests.cs

@@ -15,11 +15,13 @@ namespace TextTemplating.Tests
 	{
 		TextTemplatingAssemblyResolver resolver;
 		IProject project;
+		FakeAssemblyParserService fakeAssemblyParserService;
 		
 		void CreateResolver()
 		{
 			project = ProjectHelper.CreateProject();
-			resolver = new TextTemplatingAssemblyResolver(project);
+			fakeAssemblyParserService = new FakeAssemblyParserService();
+			resolver = new TextTemplatingAssemblyResolver(project, fakeAssemblyParserService);
 		}
 		
 		ReferenceProjectItem AddReferenceToProject(string referenceName)
@@ -29,10 +31,25 @@ namespace TextTemplating.Tests
 			return projectItem;
 		}
 
+		IProject GetProjectPassedToAssemblyParserService()
+		{
+			return ReferenceProjectItemPassedToGetReflectionProjectContentForReference.Project;
+		}
+		
+		ReferenceProjectItem ReferenceProjectItemPassedToGetReflectionProjectContentForReference {
+			get { return fakeAssemblyParserService.ItemPassedToGetReflectionProjectContentForReference; }
+		}
+		
+		ItemType GetReferenceItemTypePassedToAssemblyParserService()
+		{
+			return ReferenceProjectItemPassedToGetReflectionProjectContentForReference.ItemType;
+		}
+		
 		[Test]
 		public void Resolve_ProjectHasNoReferences_ReturnsAssemblyReferencePassedToMethod()
 		{
 			CreateResolver();
+			fakeAssemblyParserService.FakeReflectionProjectContent = null;
 			string result = resolver.Resolve("Test");
 			
 			Assert.AreEqual("Test", result);
@@ -76,5 +93,58 @@ namespace TextTemplating.Tests
 			
 			Assert.AreEqual(expectedFileName, result);
 		}
+		
+		[Test]
+		public void Resolve_ProjectHasNoReferencesAndAssemblyReferenceInGac_ReturnsFullPathToAssemblyFoundFromAssemblyParserService()
+		{
+			CreateResolver();
+			string expectedFileName = @"c:\Windows\System32\Gac\System.Data.dll";
+			fakeAssemblyParserService.FakeReflectionProjectContent.AssemblyLocation = expectedFileName;
+			
+			string result = resolver.Resolve("System.Data");
+			
+			Assert.AreEqual(expectedFileName, result);
+		}
+		
+		[Test]
+		public void Resolve_ProjectHasNoReferencesAndAssemblyReferenceInGac_ReferenceItemPassedToAssemblyParserServiceUsesProject()
+		{
+			CreateResolver();
+			string result = resolver.Resolve("System.Data");
+			IProject expectedProject = GetProjectPassedToAssemblyParserService();
+			
+			Assert.AreEqual(project, expectedProject);
+		}
+		
+		[Test]
+		public void Resolve_ProjectHasNoReferencesAndAssemblyReferenceInGac_ReferenceItemPassedToAssemblyParserServiceIsReference()
+		{
+			CreateResolver();
+			string result = resolver.Resolve("System.Data");
+			ItemType type = GetReferenceItemTypePassedToAssemblyParserService();
+			
+			Assert.AreEqual(ItemType.Reference, type);
+		}
+		
+		[Test]
+		public void Resolve_ProjectHasNoReferencesAndAssemblyReferenceInGac_ReferenceItemIncludePassedToAssemblyParserServiceIsAssemblyNameToResolve()
+		{
+			CreateResolver();
+			string result = resolver.Resolve("System.Data");
+			string referenceInclude = ReferenceProjectItemPassedToGetReflectionProjectContentForReference.Include;
+			
+			Assert.AreEqual("System.Data", referenceInclude);
+		}
+		
+		[Test]
+		public void Resolve_ProjectHasNoReferencesAndAssemblyReferenceNotFoundInGac_ReturnsAssemblyReferencePassedToMethod()
+		{
+			CreateResolver();
+			fakeAssemblyParserService.FakeReflectionProjectContent = null;
+			
+			string result = resolver.Resolve("System.Data");
+			
+			Assert.AreEqual("System.Data", result);
+		}
 	}
 }

src/AddIns/Misc/TextTemplating/Test/Src/TextTemplatingReflectionProjectContentTests.cs

@@ -0,0 +1,22 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.TextTemplating;
+using NUnit.Framework;
+
+namespace TextTemplating.Tests
+{
+	[TestFixture]
+	public class TextTemplatingReflectionProjectContentTests
+	{
+		[Test]
+		public void AssemblyLocation_NullProjectContentPassedToConstructor_ReturnsNull()
+		{
+			var projectContent = new TextTemplatingReflectionProjectContent(null);
+			string location = projectContent.AssemblyLocation;
+			
+			Assert.IsNull(location);
+		}
+	}
+}

src/AddIns/Misc/TextTemplating/Test/TextTemplating.Tests.csproj

@@ -55,6 +55,8 @@
       <Link>Configuration\GlobalAssemblyInfo.cs</Link>
     </Compile>
     <Compile Include="Configuration\AssemblyInfo.cs" />
+    <Compile Include="Helpers\FakeAssemblyParserService.cs" />
+    <Compile Include="Helpers\FakeReflectionProjectContent.cs" />
     <Compile Include="Helpers\FakeTextTemplatingAppDomain.cs" />
     <Compile Include="Helpers\FakeTextTemplatingAppDomainFactory.cs" />
     <Compile Include="Helpers\FakeTextTemplatingAssemblyResolver.cs" />
@@ -76,6 +78,7 @@
     <Compile Include="Src\TextTemplatingFilePreprocessorCustomToolTests.cs" />
     <Compile Include="Src\TextTemplatingHostTests.cs" />
     <Compile Include="Src\TextTemplatingPreprocessorTests.cs" />
+    <Compile Include="Src\TextTemplatingReflectionProjectContentTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <Folder Include="Configuration" />