public override bool IsAvailable(IUserDataHolder cache)
{
// Quick fix should be available only for exceptions, declared in the same project.
// I.e. fix would be unavailable for internal exeptions visible because of InternalVisibleTo
var project =
_highlighting.PreconditionContainer.DeclaredElement
.With(x => x.GetContainingType())
.With(x => x.GetSingleOrDefaultSourceFile())
.With(x => x.GetProject());
var exceptionProject =
_highlighting.ExceptionClass
.With(x => x.GetDeclarations().FirstOrDefault())
.With(x => x.GetProject());
// Fix is available only when exception declared in the same project!!
if (project == null || exceptionProject == null || project.Guid != exceptionProject.Guid)
{
return(false);
}
var exceptionDeclaration =
(IClassDeclaration)_highlighting.ExceptionClass.GetDeclarations().FirstOrDefault();
if (exceptionDeclaration == null)
{
return(false);
}
// TODO: terrible approach, but can't find better!
using (var workflow = GeneratorWorkflowFactory.CreateWorkflowWithoutTextControl(
GeneratorStandardKinds.Constructor,
exceptionDeclaration,
exceptionDeclaration))
{
Contract.Assert(workflow != null);
var ctors = workflow.Context.ProvidedElements
.OfType <GeneratorDeclaredElement <IConstructor> >()
.Select(c => c.DeclaredElement)
.ToList();
// TODO: refine me later!!
if (ctors.Any(ContractUtils.HasTwoStringArgument))
{
_missedConstructorPredicate = ContractUtils.HasTwoStringArgument;
_missedConstructor = "ctor(string, string)";
return(true);
}
if (ctors.Any(ContractUtils.HasOneStringArgument))
{
_missedConstructorPredicate = ContractUtils.HasOneStringArgument;
_missedConstructor = "ctor(string)";
return(true);
}
return(false);
}
}
protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
var exceptionDeclaration =
(IClassDeclaration)_highlighting.ExceptionClass.GetDeclarations().FirstOrDefault();
Contract.Assert(exceptionDeclaration != null);
using (var workflow = GeneratorWorkflowFactory.CreateWorkflowWithoutTextControl(
GeneratorStandardKinds.Constructor,
exceptionDeclaration,
exceptionDeclaration))
{
Contract.Assert(workflow != null);
var ctors = workflow.Context.ProvidedElements
.OfType <GeneratorDeclaredElement <IConstructor> >()
.Where(ge => _missedConstructorPredicate(ge.DeclaredElement))
.ToList();
Contract.Assert(ctors.Count != 0);
workflow.Context.InputElements.Clear();
workflow.Context.InputElements.AddRange(ctors);
workflow.BuildOptions();
workflow.Generate("Generate missing constructor", NullProgressIndicator.Instance);
}
return(null);
}
private void AddNonDefaultConstructorIfNeeded(IClassDeclaration contractClass)
{
if (!_addContractForAvailability.IsAbstractClass)
{
return;
}
var abstractBaseClass = _addContractForAvailability.ClassDeclaration;
using (var workflow = GeneratorWorkflowFactory.CreateWorkflowWithoutTextControl(
GeneratorStandardKinds.Constructor,
contractClass,
abstractBaseClass))
{
Contract.Assert(workflow != null);
var ctor =
workflow.Context.ProvidedElements
.OfType <GeneratorDeclaredElement <IConstructor> >()
.FirstOrDefault(c => !c.DeclaredElement.IsDefault);
if (ctor != null)
{
workflow.Context.InputElements.Clear();
workflow.Context.InputElements.Add(ctor);
workflow.BuildOptions();
workflow.Generate("Generate missing constructor", NullProgressIndicator.Instance);
}
}
}
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);
}
}
private void ImplementInterfaceOrBaseClass(IClassDeclaration contractClass, IProgressIndicator progress)
{
string generateKind = GeneratorStandardKinds.Implementations;
if (_addContractForAvailability.IsAbstractClass)
{
generateKind = GeneratorStandardKinds.Overrides;
}
using (var workflow = GeneratorWorkflowFactory.CreateWorkflowWithoutTextControl(
generateKind,
contractClass,
contractClass))
//_addContractForAvailability.TypeDeclaration))
{
Contract.Assert(workflow != null);
workflow.Context.SetGlobalOptionValue(CSharpBuilderOptions.PropertyBody,
CSharpBuilderOptions.PropertyBodyDefault);
workflow.Context.SetGlobalOptionValue(
CSharpBuilderOptions.ImplementationKind,
CSharpBuilderOptions.ImplementationKindExplicit);
//var globalActions = workflow.Context.GlobalOptions;
//var dd = globalActions
// .FirstOrDefault(g => g.ID == CSharpBuilderOptions.ImplementationKind);
//if (dd != null)
//{
// dd.OverridesGlobalOption = true;
// dd.Value = CSharpBuilderOptions.ImplementationKindPublicMember;
//}
workflow.Context.Anchor = contractClass;
workflow.Context.InputElements.Clear();
Contract.Assert(workflow.Context.ProvidedElements.Count != 0);
workflow.Context.InputElements.AddRange(workflow.Context.ProvidedElements);
//foreach (var e in workflow.Context.ProvidedElements)
//{
// workflow.Context.InputElements.Add(e);
//}
//workflow.Context.GlobalOptions.Clear();
workflow.GenerateAndFinish("Generate contract class", progress);
}
}
private void ImplementContractForAbstractClass(IClassDeclaration contractClass,
IClassDeclaration abstractClass)
{
Contract.Requires(contractClass != null);
Contract.Requires(contractClass.DeclaredElement != null);
Contract.Requires(abstractClass != null);
Contract.Requires(abstractClass.DeclaredElement != null);
using (var workflow = GeneratorWorkflowFactory.CreateWorkflowWithoutTextControl(
GeneratorStandardKinds.Overrides,
contractClass,
abstractClass))
{
Contract.Assert(workflow != null);
// By default this input for this workflow contains too many members:
// It contains member from the base class (required) and
// members from the other base classes (i.e. from System.Object).
// Using some hack to get only members defined in the "abstractClass"
// So I'm trying to find required elements myself.
var missingMembers = contractClass.GetMissingMembersOf(abstractClass);
if (_requiredFunction != null)
{
var requiredDeclaration = _requiredFunction.DeclaredElement;
missingMembers =
missingMembers.Where(x => GetMembers(x).Any(m => m.Equals(requiredDeclaration)))
.ToList();
Contract.Assert(missingMembers.Count != 0, "Should be at least one method to add!");
}
var membersToOverride =
missingMembers
.Select(x => new GeneratorDeclaredElement <IOverridableMember>(x.Member, x.Substitution))
.ToList();
workflow.Context.InputElements.Clear();
workflow.Context.ProvidedElements.Clear();
workflow.Context.ProvidedElements.AddRange(membersToOverride);
workflow.Context.InputElements.AddRange(workflow.Context.ProvidedElements);
workflow.Generate("Generate contract class", NullProgressIndicator.Instance);
}
}
