/// <inheritdoc/>
public (string nameSpace, string name) Generate(
IWriterSelector writerSelector,
IInterfaceDeclaration itfDeclaration,
string implName)
{
if (itfDeclaration == null)
{
throw new ArgumentNullException(nameof(itfDeclaration), $"The argument {nameof(itfDeclaration)} was null.");
}
var(location, nameSpace) = this.locator.ComputeTargetLocation(itfDeclaration.DeclarationNameSpace);
this.generator.Generate(location, implName, writer =>
{
var generatorWalker = new ImplementationGeneratorWalker(
writer,
this.itfPattern,
this.implPattern,
itfDeclaration,
implName,
nameSpace,
writerSelector);
generatorWalker.Visit(this.implPattern.SyntaxNodeProvider.SyntaxNode.SyntaxTree.GetRoot());
});
return(nameSpace, implName);
}
private static bool IsDeclarationInProject(IInterfaceDeclaration itfDeclaration, ICSharpProject project)
{
var filePath = itfDeclaration.Location;
var projectPath = project.ProjectPath;
return(filePath.StartsWith(projectPath, StringComparison.InvariantCulture));
}
/// <summary>
/// Initializes a new instance of the <see cref="ImplementationGenerator"/> class.
/// </summary>
/// <param name="generator">The generator to use to generate the output.</param>
/// <param name="locator">Code generation locator.</param>
/// <param name="itfPattern">The interface pattern to use for the generator.</param>
/// <param name="implPattern">The implementation pattern to use for the generator.</param>
public ImplementationGenerator(IGenerator generator, ILocator locator, IInterfaceDeclaration itfPattern, IGenericDeclaration <SyntaxNode> implPattern)
{
this.generator = generator;
this.itfPattern = itfPattern;
this.implPattern = implPattern;
this.locator = locator;
}
private IDeclarationResolver LoadWorkSpace(
string patternInterfaceFile,
string patternImplementationFile,
string declarationInterfaceFile,
out IInterfaceDeclaration itfDeclaration,
out IInterfaceDeclaration itfPatternDeclaration,
out IClassDeclaration implPatternDeclaration,
out IEnumerable <ICSharpFile> files)
{
using (var ws = new CSharpWorkspace(
Mock.Of <ILogger <CSharpWorkspace> >(),
new CSharpFactory(
Mock.Of <ILoggerFactory>(),
DeclarationHelper.CreateDeclarationFactory(this.testOutputHelper)),
new CSharpLoader()))
{
itfDeclaration = ws.RegisterFile(declarationInterfaceFile)
.Declarations.First() as IInterfaceDeclaration;
itfPatternDeclaration = ws.RegisterFile(patternInterfaceFile)
.Declarations.First() as IInterfaceDeclaration;
implPatternDeclaration = ws.RegisterFile(patternImplementationFile)
.Declarations.First() as IClassDeclaration;
files = ws.Files;
return(ws.DeepLoad());
}
}
private void ImplementContractForInterface(IClassDeclaration contractClass,
IInterfaceDeclaration interfaceDeclaration)
{
Contract.Requires(contractClass != null);
Contract.Requires(interfaceDeclaration != null);
if (interfaceDeclaration.MemberDeclarations.Count == 0)
{
return;
}
using (var workflow = GeneratorWorkflowFactory.CreateWorkflowWithoutTextControl(
GeneratorStandardKinds.MissingMembers,
contractClass,
interfaceDeclaration))
{
Contract.Assert(workflow != null);
workflow.Context.InputElements.Clear();
workflow.Context.InputElements.AddRange(workflow.Context.ProvidedElements);
workflow.Context.SetOption(
CSharpBuilderOptions.ImplementationKind,
CSharpBuilderOptions.ImplementationKindExplicit);
workflow.Generate("Generate contract class", NullProgressIndicator.Instance);
}
}
public override void VisitInterfaceDeclaration(IInterfaceDeclaration decl, SST context)
{
if (!_isAlreadyInsideTypeDeclaration)
{
_isAlreadyInsideTypeDeclaration = true;
base.VisitInterfaceDeclaration(decl, context);
_isAlreadyInsideTypeDeclaration = false;
}
}
private static IWriterSelector SetupWriterSelector(
IInterfaceDeclaration itfPatternDeclaration,
IClassDeclaration implPatternDeclaration,
IInterfaceDeclaration itfDeclaration,
string implName)
{
var propertyWriter = new PropertyWriter(
itfPatternDeclaration.Properties.Single(),
itfDeclaration.Properties.ToArray());
var itfNameWriter = new StringReplaceWriter(itfPatternDeclaration.Name, itfDeclaration.Name);
var implNameWriter = new StringReplaceWriter(implPatternDeclaration.Name, implName);
return(new WriterSelector(propertyWriter, itfNameWriter, implNameWriter));
}
/// <summary>
/// Initializes a new instance of the <see cref="ImplementationGeneratorWalker"/> class.
/// </summary>
/// <param name="writer">The writer where to write generated code.</param>
/// <param name="itfPattern">Interface pattern.</param>
/// <param name="implPattern">Implementation pattern.</param>
/// <param name="itfDeclaration">Interface declaration to implement.</param>
/// <param name="implName">Implementation name.</param>
/// <param name="implNameSpace">Implementation name space.</param>
/// <param name="writerSelector">Writer selector.</param>
/// <param name="textSubstitutionHandler">Optional text substitution handler.</param>
public ImplementationGeneratorWalker(
TextWriter writer,
IInterfaceDeclaration itfPattern,
IGenericDeclaration <SyntaxNode> implPattern,
IInterfaceDeclaration itfDeclaration,
string implName,
string implNameSpace,
IWriterSelector writerSelector,
Func <string, string> textSubstitutionHandler = null)
{
this.writer = writer;
this.itfPattern = itfPattern;
this.implPattern = implPattern;
this.declaration = itfDeclaration;
this.implName = implName;
this.implNameSpace = implNameSpace;
this.writerSelector = writerSelector;
this.textSubstitutionHandler = textSubstitutionHandler ?? SameText;
}
private void AnalyzeInterfaceDeclaration(IInterfaceDeclaration source)
{
var flags = GetModifiers(source);
AddOrCreateDeclarationSymbol(SymbolKind.InterfaceDeclaration, source.Name.Text, flags);
AnalyzeDecorators(source);
using (m_currentLocationStack.AutoPush(source.Name.Text))
{
// Base types
AnalyzeHeritageClause(source.HeritageClauses.Elements);
// Members
AnalyzeInterfaceMembers(source.Members, registerPropertyNames: true);
// Type parameters
AnalyzeTypeParameters(source.TypeParameters);
}
}
private void ImplementContractForInterface(IClassDeclaration contractClass,
IInterfaceDeclaration interfaceDeclaration)
{
Contract.Requires(contractClass != null);
Contract.Requires(interfaceDeclaration != null);
if (interfaceDeclaration.MemberDeclarations.Count == 0)
return;
using (var workflow = GeneratorWorkflowFactory.CreateWorkflowWithoutTextControl(
GeneratorStandardKinds.MissingMembers,
contractClass,
interfaceDeclaration))
{
Contract.Assert(workflow != null);
workflow.Context.InputElements.Clear();
workflow.Context.InputElements.AddRange(workflow.Context.ProvidedElements);
workflow.Context.SetOption(
CSharpBuilderOptions.ImplementationKind,
CSharpBuilderOptions.ImplementationKindExplicit);
workflow.Generate("Generate contract class", NullProgressIndicator.Instance);
}
}
/// <inheritdoc />
public override void VisitInterfaceDeclaration(IInterfaceDeclaration node)
{
Register(node, node.Flags, DocNodeType.Interface, node.Name.Text, base.VisitInterfaceDeclaration);
}
