public StudentsController(
IStudentsProvider studentsProvider,
IStudentCreator studentCreator,
IStudentDestructor studentDestructor,
IStudentUpdater studentUpdater,
IEmployeesProvider employeesProvider,
IModesProvider modesProvider,
IStudentsImporter studentsImporter,
IContractProvider contractProvider,
IContractUpdater contractUpdater,
IContractGenerator contractGenerator,
IUniversityDetailsProvider universityDetailsProvider,
ICompaniesProvider companiesProvider,
ICoursesProvider coursesProvider,
ICompanyCreator companyCreator)
{
_studentsProvider = studentsProvider;
_studentCreator = studentCreator;
_studentDestructor = studentDestructor;
_studentUpdater = studentUpdater;
_employeesProvider = employeesProvider;
_modesProvider = modesProvider;
_studentsImporter = studentsImporter;
_contractProvider = contractProvider;
_contractUpdater = contractUpdater;
_contractGenerator = contractGenerator;
_universityDetailsProvider = universityDetailsProvider;
_coursesProvider = coursesProvider;
_companiesProvider = companiesProvider;
_companyCreator = companyCreator;
}
public BasicAnalysisDriver(IMetaDataProvider metaDataProvider,
IContractProvider contractProvider)
{
SubroutineFacade = new SubroutineFacade(metaDataProvider, contractProvider);
this.meta_data_provider = metaDataProvider;
this.contract_provider = contractProvider;
}
public BasicAnalysisDriver (IMetaDataProvider metaDataProvider,
IContractProvider contractProvider)
{
SubroutineFacade = new SubroutineFacade (metaDataProvider, contractProvider);
this.meta_data_provider = metaDataProvider;
this.contract_provider = contractProvider;
}
/// <summary>
/// Wraps a call to GetTypeContractFor inside of a try-catch statement.
/// </summary>
public static bool TryGetTypeContract(CodeContractAwareHostEnvironment host, ITypeReference type, out ITypeContract typeContract, DocTracker docTracker)
{
Contract.Requires(host != null);
Contract.Requires(type != null);
Contract.Ensures(!Contract.Result <bool>() || Contract.ValueAtReturn(out typeContract) != null);
try {
var unit = TypeHelper.GetDefiningUnit(type.ResolvedType);
if (unit == null)
{
typeContract = null;
}
else
{
IContractProvider lcp = host.GetContractExtractor(unit.UnitIdentity);
if (lcp == null)
{
typeContract = null;
}
else
{
typeContract = lcp.GetTypeContractFor(type);
}
}
} catch (NullReferenceException) {
docTracker.WriteLine("ERROR: NullReferenceException was thrown in CCI!");
typeContract = null;
}
return(typeContract != null);
}
public SubroutineFacade(IMetaDataProvider metaDataProvider,
IContractProvider contractProvider)
{
this.MetaDataProvider = metaDataProvider;
this.ContractProvider = contractProvider;
this.requires_factory = new RequiresFactory(this);
// this.ensures_factory = new EnsuresFactory (this);
}
public CciTypeDefinition(Microsoft.Cci.ITypeDefinition typeDefinition, IContractProvider contractProvider)
{
Contract.Requires(typeDefinition != null);
Contract.Requires(contractProvider != null);
this.typeDefinition = typeDefinition;
this.contractProvider = contractProvider;
}
public CodeLayer(IILDecoder <APC, Expression, Variable, ContextData, EdgeData> ilDecoder,
IMetaDataProvider metadataDecoder,
IContractProvider contractDecoder,
Func <Expression, string> expressionToString,
Func <Variable, string> variableToString, ILPrinter <APC> printer)
: this(ilDecoder, metadataDecoder, contractDecoder, expressionToString, variableToString)
{
this.printer = new Lazy <ILPrinter <APC> > (() => printer);
}
Create <Expression, Variable, ContextData, EdgeConversionData> (
IILDecoder <APC, Expression, Variable, ContextData, EdgeConversionData> ilDecoder,
IMetaDataProvider metadataDecoder,
IContractProvider contractDecoder, Func <Expression, string> expressionToString, Func <Variable, string> variableToString, ILPrinter <APC> printer)
where ContextData : IMethodContextProvider
{
return(new CodeLayer <Expression, Variable, ContextData, EdgeConversionData>
(ilDecoder, metadataDecoder, contractDecoder, expressionToString, variableToString, printer));
}
/// <summary>
/// Creates a ContractTraverser
/// </summary>
/// <param name="contractProvider">The contract provider.</param>
/// <param name="membersElement">The XElement of the "members" element in a XML file</param>
/// <param name="options">The options.</param>
/// <param name="host">The host environment of the traverser. Used to pull inherited contracts.</param>
public ContractTraverser(HostEnvironment host, IContractProvider contractProvider, XElement membersElement, Options options)
{
Contract.Requires(contractProvider != null);
Contract.Requires(membersElement != null);
Contract.Requires(options != null);
this.contractProvider = contractProvider;
this.membersElement = membersElement;
this.options = options;
this.host = host;
}
/// <summary>
/// A class that traverses the contract, code and metadata models in depth first, left to right order.
/// </summary>
public CciContractTraverser(IContractProvider contractProvider, ICodeAndContractVisitor preorderVisitor)
{
Contract.Requires(contractProvider != null);
Contract.Requires(preorderVisitor != null);
this.contractProvider = contractProvider;
this.preorderVisitor = preorderVisitor;
PreorderVisitor = preorderVisitor;
dispatchingVisitor = new CciContractElementDispatcher(this);
}
public CodeLayer(IILDecoder <APC, Expression, Variable, ContextData, EdgeData> ilDecoder,
IMetaDataProvider metadataDecoder,
IContractProvider contractDecoder,
Func <Expression, string> expressionToString,
Func <Variable, string> variableToString)
{
ExpressionToString = expressionToString;
VariableToString = variableToString;
ILDecoder = ilDecoder;
MetaDataProvider = metadataDecoder;
ContractProvider = contractDecoder;
this.printer = new Lazy <ILPrinter <APC> > (() => PrinterFactory.Create(ILDecoder, MetaDataProvider, ExpressionToString, VariableToString));
}
public AddContractRefactoring(
IEnumerable <BlockSyntax> bodies,
ContractParameter parameter,
IContractProvider provider,
ContractKind contractKind)
{
Contract.Requires(bodies != null);
Contract.Requires(provider != null);
Contract.Requires(Enum.IsDefined(typeof(ContractKind), contractKind));
_bodies = bodies;
_parameter = parameter;
_provider = provider;
_contractKind = contractKind;
}
protected SyntaxVisitorBase(SemanticModel model, ICompileContext context, IContractProvider contractProvider)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (contractProvider == null)
{
throw new ArgumentNullException(nameof(contractProvider));
}
this.model = model;
this.context = context;
this.contractProvider = contractProvider;
this.nodeRewriter = new NodeRewriter(model, context);
}
static void Main(string[] args)
{
OrdinarBookFactory ordinarFactory = new OrdinarBookFactory();
CollectionBookFactory collectionFactory = new CollectionBookFactory();
Book ordinarBook = ordinarFactory.MakeBook("Кац Яков Михайлович",
"Шушпанов Аркадий Васильевич",
"Черногорская Маринна Витальевна",
"Параноидальное танго");
Book collectionBook = collectionFactory.MakeBook("Клин Клим Климович",
"Берестов Демьян Прокофьевич",
"Факторович Леонид Львович",
"Эволюция. Тщетность.");
PublishingOffice <IBook> office = new PublishingOffice <IBook>("Буква")
{
ordinarBook,
collectionBook
};
office.PrintBooks();
Console.WriteLine($"Удалим одну книгу");
office.Remove(ordinarBook);
office.PrintBooks();
Console.WriteLine();
office.HireActorWithReward(new Writer <IReward>("Василий Сергеевич Чесноков", new Reward(300000)));
office.HireActorWithWage(new Publisher <IWage>("Николай Александрович Клим", new Wage(30000, 31)));
office.PrintMembers();
IContractProvider <IPerson> personContract = new PublishingOffice <IBook>("Эксмо");
IContractProvider <IActor <ISalary> > actorContract = personContract;
actorContract.PrintContract(new Publisher <IWage>("Юлия Львовна Липская", new Wage(7000, 7)));
Console.ReadLine();
}
public static IEnumerable <Contract> GetDeclaredPreconditions(this IMethodSymbol @this, SemanticModel model, IContractProvider contractProvider)
{
if (@this == null)
{
throw new ArgumentNullException(nameof(@this));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (contractProvider == null)
{
throw new ArgumentNullException(nameof(contractProvider));
}
return(@this
.Parameters
.SelectMany(p => p.GetAttributes())
.Where(a => a.IsContractAttribute(model))
.Select(a => contractProvider[a.AttributeClass.Name.ToString().Trim()]));
}
public static IEnumerable <Contract> GetDeclaredContracts(this IMethodSymbol @this, SemanticModel model, IContractProvider contractProvider) =>
@this.GetDeclaredPreconditions(model, contractProvider).Concat(
@this.GetDeclaredPostconditions(model, contractProvider));
public CciContractParameterVisitor(IContractProvider contractProvider)
{
Contract.Requires(contractProvider != null);
usesAParameter = false;
}
public MetadataTraverser(Sink sink, IContractProvider cp)
: base() {
this.sink = sink;
this.factory = sink.Factory;
ContractProvider = cp;
}
/// <summary>
/// A class that traverses the contract, code and metadata models in depth first, left to right order.
/// </summary>
public CodeAndContractTraverser(IContractProvider/*?*/ contractProvider)
{
this.contractProvider = contractProvider;
this.dispatchingVisitor = new ContractElementDispatcher() { traverser = this };
}
public virtual MetadataTraverser MakeMetadataTraverser(IContractProvider contractProvider) { return new MetadataTraverser(new Sink(this), contractProvider); }
public static TNode WithContracts <TNode>(this TNode @this, SemanticModel model, IContractProvider contractProvider)
where TNode : MemberDeclarationSyntax
{
if (@this == null)
{
throw new ArgumentNullException(nameof(@this));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (contractProvider == null)
{
throw new ArgumentNullException(nameof(contractProvider));
}
//HACK: Must use dynamic because of limitation with generic constraints.
return(typeof(TNode).IsSubclassOf(typeof(BaseMethodDeclarationSyntax))
? MethodWithContracts((dynamic)@this, model, contractProvider)
: PropertyWithContracts((dynamic)@this, model, contractProvider));
}
public AutoPropertyExpander(SemanticModel model, ICompileContext context, IContractProvider contractProvider)
: base(model, context, contractProvider)
{
}
public Analyzer(SemanticModel model, ICompileContext context, IContractProvider contractProvider)
: base(model, context, contractProvider)
{
}
public Injector(SemanticModel model, ICompileContext context, IContractProvider contractProvider)
: base(model, context, contractProvider)
{
}
public static IEnumerable <Contract> GetContracts(this IPropertySymbol @this, SemanticModel model, IContractProvider contractProvider) =>
@this.GetPreconditions(model, contractProvider).Concat(
@this.GetPostconditions(model, contractProvider));
protected ConcreteTypeMemberExpander(SemanticModel model, ICompileContext context, IContractProvider contractProvider)
: base(model, context, contractProvider)
{
}
public static IEnumerable <Contract> GetPostconditions(this IPropertySymbol @this, SemanticModel model, IContractProvider contractProvider)
{
if (@this == null)
{
throw new ArgumentNullException(nameof(@this));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (contractProvider == null)
{
throw new ArgumentNullException(nameof(contractProvider));
}
return(@this.IsWriteOnly
? Enumerable.Empty <Contract>()
: @this
.DeclaredAndInheritedAttributes()
.Where(a => a.IsContractAttribute(model))
.Select(a => contractProvider[a.AttributeClass.Name.ToString().Trim()]));
}
public static IEnumerable <Contract> GetPreconditions(this ParameterSyntax @this, SemanticModel model, IContractProvider contractProvider)
{
if (@this == null)
{
throw new ArgumentNullException(nameof(@this));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (contractProvider == null)
{
throw new ArgumentNullException(nameof(contractProvider));
}
var attributeTypeSymbol = typeof(ContractAttribute).GetTypeSymbol(model);
return(@this.AllAttributes()
.Where(a => model.GetTypeInfo(a).Type.InheritsFrom(attributeTypeSymbol))
.Select(a => contractProvider[a.GetText().ToString().Trim()]));
}
/// <summary>
/// Allocates a visitor that traverses a code model model in depth first, left to right order.
/// </summary>
public BaseCodeAndContractTraverser(IContractProvider/*?*/ contractProvider)
{
this.contractProvider = contractProvider;
}
public CciContractVisitor(IContractProvider contractProvider)
{
Contract.Requires(contractProvider != null);
instanceIsUsed = false;
}
/// <summary>
/// Contains a specialized Visit routine for each standard type of object defined in the contract, code and metadata model.
/// </summary>
public CodeAndContractVisitor(IContractProvider/*?*/ contractProvider)
{
this.contractProvider = contractProvider;
}
public CciContractDependenciesAnalyzer(IContractProvider contractProvider)
{
this.contractProvider = contractProvider;
}
private static TMethodSyntax MethodWithContracts <TMethodSyntax>(this TMethodSyntax @this, SemanticModel model, IContractProvider contractProvider)
where TMethodSyntax : BaseMethodDeclarationSyntax
{
var symbol = model.GetMethodSymbol(@this);
var preconditionStatements = symbol
.Parameters
.SelectMany(parameter => parameter
.GetPreconditions(model, contractProvider)
.Select(contract => new _PreconditionParameters(contract, parameter)))
.Select(x => PreconditionStatement(x.Contract, x.ParameterType, x.ParameterName));
var returnType = model.GetTypeInfo(@this.ReturnType()).Type;
var returnStatements = @this.GetReturnStatements();
var postconditions = symbol
.GetPostconditions(model, contractProvider);
var result = @this.ReplaceNodes(returnStatements,
(oldNode, newNode) => PostconditionStatement(postconditions, returnType, oldNode, model));
return(result
.WithBody(result.Body
.WithStatements(new SyntaxList <StatementSyntax>()
.AddRange(preconditionStatements)
.AddRange(result.Body.Statements))));
}
public static IEnumerable <Contract> GetContracts(this BaseMethodDeclarationSyntax @this, SemanticModel model, IContractProvider contractProvider) =>
@this.GetPreconditions(model, contractProvider).Concat(
@this.GetPostconditions(model, contractProvider));
public ExpressionBodiedMemberExpander(SemanticModel model, ICompileContext context, IContractProvider contractProvider)
: base(model, context, contractProvider)
{
}
private static TPropertySyntax PropertyWithContracts <TPropertySyntax>(this TPropertySyntax @this, SemanticModel model, IContractProvider contractProvider)
where TPropertySyntax : BasePropertyDeclarationSyntax
{
var symbol = model.GetPropertySymbol(@this);
var indexer = @this as IndexerDeclarationSyntax;
var paramPreconditions = (indexer == null)
? Enumerable.Empty <_PreconditionParameters>()
: model.GetPropertySymbol(indexer)
.Parameters
.SelectMany(p => p.GetPreconditions(model, contractProvider)
.Select(contract => new _PreconditionParameters(contract, p)));
var setter = @this.Setter();
if (setter != null)
{
var preconditions = symbol
.GetPreconditions(model, contractProvider)
.Select(contract => new _PreconditionParameters(contract, symbol.Type, "value"))
.Concat(paramPreconditions);
var statements = preconditions
.Select(x => PreconditionStatement(x.Contract, x.ParameterType, x.ParameterName))
.Concat(setter.Body.Statements)
.ToArray();
setter = setter.WithBody(Block(statements));
}
var getter = @this.Getter();
if (getter != null)
{
var returnStatements = getter.GetReturnStatements();
var postconditions = symbol
.GetPostconditions(model, contractProvider);
getter = getter.ReplaceNodes(returnStatements,
(oldNode, newNode) => PostconditionStatement(postconditions, symbol.Type, oldNode, model));
var statements = paramPreconditions
.Select(x => PreconditionStatement(x.Contract, x.ParameterType, x.ParameterName))
.Concat(getter.Body.Statements)
.ToArray();
getter = getter.WithBody(Block(statements));
}
var accessors = AccessorList(List(
new[] {
getter,
setter
}
.Where(a => a != null)));
//HACK: Must cast to dynamic because WithAccessorList is only defined on subclasses
return(((dynamic)@this).WithAccessorList(accessors));
}
