private MethodDefinition CreateMethod(string name, Action action, HashSet <IParameterDefinition> parameters)
{
var method = new MethodDefinition
{
CallingConvention = CallingConvention.HasThis,
InternFactory = host.InternFactory,
IsStatic = false,
Name = host.NameTable.GetNameFor(name),
Type = action.Method.Type,
Visibility = TypeMemberVisibility.Public,
Parameters = parameters.ToList()
};
BlockStatement block = null;
// TODO (lleraromero): Por el momento hacemos solo inlining porque sirve para CC / Corral. Realmente deberiamos tener un creador del cuerpo polimorfico
//if (Configuration.InlineMethodsBody)
//{
block = InlineMethodBody(action);
//}
//else
//{
// block = CallMethod(action);
//}
method.Body = new SourceMethodBody(host)
{
MethodDefinition = method,
Block = block,
LocalsAreZeroed = true
};
return(method);
}
public IReadOnlyCollection <Transition> AnalyzeTransitions(State source, Action action, IEnumerable <State> targets)
{
var evaluator = new QueryEvaluator(new CorralMock(), new FileInfo(@"C:\Windows\notepad.exe"));
var transitionQueries = CreateTransitionQueries(source, action, targets);
return(evaluator.GetFeasibleTransitions(transitionQueries));
}
public IReadOnlyCollection <Transition> AnalyzeTransitions(State source, Action action, IEnumerable <State> targets)
{
Contract.Requires(source != null);
Contract.Requires(action != null);
Contract.Requires(targets.Any());
Contract.Ensures(Contract.Result <IReadOnlyCollection <Transition> >().Any());
throw new NotImplementedException();
}
public ActionAnalysisResults AnalyzeActions(State source, Action action, IEnumerable <Action> actions)
{
Contract.Requires(source != null);
Contract.Requires(action != null);
Contract.Requires(actions.Any());
Contract.Ensures(Contract.Result <ActionAnalysisResults>() != null);
throw new NotImplementedException();
}
private MethodDefinition CreateQueryMethod(State state, string name, Action action, State target)
{
var parameters = GetStateParameters(state);
parameters.UnionWith(action.Method.Parameters);
parameters.UnionWith(GetStateParameters(target));
return(CreateMethod(name, action, parameters));
}
private BlockStatement CallMethod(Action action)
{
throw new NotSupportedException();
//var block = new BlockStatement();
//var args = new List<IExpression>();
//foreach (var arg in action.Parameters)
//{
// args.Add(new BoundExpression()
// {
// Definition = arg,
// Instance = null,
// Locations = new List<ILocation>(arg.Locations),
// Type = arg.Type
// });
//}
//IMethodReference methodReference = action;
//if (typeToAnalyze.IsGeneric)
//{
// methodReference = specializedInputType.SpecializeMember(action, host.InternFactory) as IMethodReference;
//}
//var callExpr = new MethodCall()
//{
// Arguments = args,
// IsStaticCall = false,
// MethodToCall = methodReference,
// Type = action.Type,
// ThisArgument = new ThisReference(),
// Locations = new List<ILocation>(action.Locations)
//};
//if (action.Type.TypeCode == PrimitiveTypeCode.Void)
//{
// var call = new ExpressionStatement()
// {
// Expression = callExpr
// };
// block.Statements.Add(call);
//}
//else
//{
// var ret = new ReturnStatement()
// {
// Expression = callExpr
// };
// block.Statements.Add(ret);
//}
//return block;
}
protected IReadOnlyCollection <ActionQuery> CreateQueries(State state, Action action, IEnumerable <Action> actions,
CciActionQueryGenerator queryGenerator)
{
var queries = new List <ActionQuery>();
foreach (var actionUnderTest in actions)
{
queries.Add(queryGenerator.CreateQuery(state, action, actionUnderTest));
}
return(queries);
}
private Action GenerateQuery(State state, Action action, State target)
{
var actionName = action.Name;
var stateName = state.Name;
var targetName = target.Name;
var methodName = string.Format("{1}{0}{2}{0}{3}", MethodNameDelimiter, stateName, actionName, targetName);
var method = CreateQueryMethod(state, methodName, action, target);
var queryContract = CreateQueryContract(state, target);
return(new CciAction(method, queryContract));
}
public IReadOnlyCollection <Transition> AnalyzeTransitions(State source, Action action, IEnumerable <State> targets)
{
ISolver corralRunner = new CorralRunner(defaultArgs, workingDir);
var transitionQueries = queryGenerator.CreateTransitionQueries(source, action, targets);
var queryAssembly = CreateBoogieQueryAssembly(transitionQueries);
var evaluator = new QueryEvaluator(corralRunner, queryAssembly);
var feasibleTransitions = evaluator.GetFeasibleTransitions(transitionQueries);
unprovenQueriesCount += evaluator.UnprovenQueries;
return(feasibleTransitions);
}
public IReadOnlyCollection <Transition> AnalyzeTransitions(State source, Action action, IEnumerable <State> targets)
{
var codeContractsRunner = new CodeContractsRunner(workingDir, ccCheckDefaultArgs, libPaths, typeToAnalyze);
var transitionQueries = queryGenerator.CreateTransitionQueries(source, action, targets);
var queryAssembly = CreateQueryAssembly(transitionQueries);
var evaluator = new QueryEvaluator(codeContractsRunner, queryAssembly);
var feasibleTransitions = evaluator.GetFeasibleTransitions(transitionQueries);
unprovenQueriesCount += evaluator.UnprovenQueries;
return(feasibleTransitions);
}
public ActionAnalysisResults AnalyzeActions(State source, Action action, IEnumerable <Action> actions)
{
var evaluator = new QueryEvaluator(new CorralMock(), new FileInfo(@"C:\Windows\notepad.exe"));
var negativeQueries = CreateNegativeQueries(source, action, actions);
var disabledActions = new HashSet <Action>(evaluator.GetDisabledActions(negativeQueries));
var positiveQueries = CreatePositiveQueries(source, action, actions);
var enabledActions = new HashSet <Action>(evaluator.GetEnabledActions(positiveQueries));
Contract.Assert(!enabledActions.Intersect(disabledActions).Any());
return(new ActionAnalysisResults(enabledActions, disabledActions));
}
public ActionAnalysisResults AnalyzeActions(State source, Action action, IEnumerable <Action> actions)
{
ISolver corralRunner = new CorralRunner(defaultArgs, workingDir);
if (action.IsPure)
{
return(new ActionAnalysisResults(new HashSet <Action>(source.EnabledActions), new HashSet <Action>(source.DisabledActions)));
}
var enabledActions = GetMustBeEnabledActions(source, action, actions, corralRunner);
var disabledActions = GetMustBeDisabledActions(source, action, actions, corralRunner);
Contract.Assert(!enabledActions.Intersect(disabledActions).Any());
return(new ActionAnalysisResults(enabledActions, disabledActions));
}
protected ISet <Action> GetMustBeDisabledActions(State source, Action action, IEnumerable <Action> actions, ISolver corralRunner)
{
Contract.Requires(source != null);
Contract.Requires(action != null);
Contract.Requires(actions.Any());
Contract.Requires(corralRunner != null);
var targetNegatedPreconditionQueries = queryGenerator.CreateNegativeQueries(source, action, actions);
generatedQueriesCount += targetNegatedPreconditionQueries.Count;
var queryAssembly = CreateBoogieQueryAssembly(targetNegatedPreconditionQueries);
var evaluator = new QueryEvaluator(corralRunner, queryAssembly);
var disabledActions = new HashSet <Action>(evaluator.GetDisabledActions(targetNegatedPreconditionQueries));
unprovenQueriesCount += evaluator.UnprovenQueries;
return(disabledActions);
}
protected ISet <Action> ActionsThatAreAlwaysEnabled(State source, Action action, IEnumerable <Action> actions,
CodeContractsRunner codeContractsRunner)
{
Contract.Requires(source != null);
Contract.Requires(action != null);
Contract.Requires(actions.Any());
Contract.Requires(codeContractsRunner != null);
var targetPreconditionQueries = queryGenerator.CreatePositiveQueries(source, action, actions);
generatedQueriesCount += targetPreconditionQueries.Count;
var queryAssembly = CreateQueryAssembly(targetPreconditionQueries);
var evaluator = new QueryEvaluator(codeContractsRunner, queryAssembly);
var enabledActions = new HashSet <Action>(evaluator.GetEnabledActions(targetPreconditionQueries));
unprovenQueriesCount += evaluator.UnprovenQueries;
return(enabledActions);
}
public ActionAnalysisResults AnalyzeActions(State source, Action action, IEnumerable <Action> actions)
{
var codeContractsRunner = new CodeContractsRunner(workingDir, ccCheckDefaultArgs, libPaths, typeToAnalyze);
if (action.IsPure)
{
return(new ActionAnalysisResults(new HashSet <Action>(source.EnabledActions), new HashSet <Action>(source.DisabledActions)));
}
var enabledActions = ActionsThatAreAlwaysEnabled(source, action, actions, codeContractsRunner);
var disabledActions = ActionsThatAreAlwaysDisabled(source, action, actions, codeContractsRunner);
if (enabledActions.Intersect(disabledActions).Any())
{
Logger.Log(LogLevel.Warn,
"Suspicious state! Only a state with a unsatisfiable invariant can lead to actions being enabled and disabled at the same time. It can also mean a bug in our code.");
return(new ActionAnalysisResults(new HashSet <Action>(source.EnabledActions), new HashSet <Action>(source.DisabledActions)));
}
return(new ActionAnalysisResults(enabledActions, disabledActions));
}
public IReadOnlyCollection <TransitionQuery> CreateTransitionQueries(State sourceState, Action action, IEnumerable <State> targetStates)
{
return
(targetStates.Select(
targetState => new TransitionQuery(GenerateQuery(sourceState, action, targetState), sourceState, action, targetState)).ToList());
}
protected IReadOnlyCollection <ActionQuery> CreateNegativeQueries(State source, Action action, IEnumerable <Action> actions)
{
var queries = new List <ActionQuery>();
foreach (var a in actions)
{
var prefix = notPrefix;
var actionName = action.Name;
var stateName = source.Name;
var targetName = a.Name;
var methodName = string.Format("{1}{0}{2}{0}{3}{4}", methodNameDelimiter, stateName, actionName, prefix, targetName);
var fakeAction = A.Fake <Action>();
A.CallTo(() => fakeAction.Name).Returns(CreateUniqueMethodName(methodName));
var fakeQuery = new ActionQuery(fakeAction, QueryType.Negative, a);
queries.Add(fakeQuery);
}
return(queries);
}
protected IReadOnlyCollection <TransitionQuery> CreateTransitionQueries(State source, Action action, IEnumerable <State> targets)
{
var queries = new List <TransitionQuery>();
foreach (var s in targets)
{
var actionName = action.Name;
var stateName = source.Name;
var targetName = s.Name;
var methodName = string.Format("{1}{0}{2}{0}{3}", methodNameDelimiter, stateName, actionName, targetName);
var fakeAction = A.Fake <Action>();
A.CallTo(() => fakeAction.Name).Returns(CreateUniqueMethodName(methodName));
var fakeQuery = new TransitionQuery(fakeAction, source, action, s);
queries.Add(fakeQuery);
}
return(queries);
}
private BlockStatement InlineMethodBody(Action action)
{
var block = new BlockStatement();
var mc = action.Contract;
if (mc != null && mc.Preconditions.Any())
{
var asserts = from pre in mc.Preconditions
select new AssertStatement
{
Condition = pre.Condition,
OriginalSource = pre.OriginalSource,
Description = new CompileTimeConstant {
Value = "Inlined method precondition", Type = host.PlatformType.SystemString
}
};
block.Statements.AddRange(asserts);
}
IBlockStatement actionBodyBlock = null;
if (action.Method.Body is Microsoft.Cci.ILToCodeModel.SourceMethodBody)
{
var actionBody = action.Method.Body as Microsoft.Cci.ILToCodeModel.SourceMethodBody;
actionBodyBlock = actionBody.Block;
}
else if (action.Method.Body is SourceMethodBody)
{
var actionBody = action.Method.Body as SourceMethodBody;
actionBodyBlock = actionBody.Block;
}
//Por tratarse de un constructor skipeamos
//el primer statement porque es base..ctor();
var skipCount = action.Method.IsConstructor ? 1 : 0;
block.Statements.AddRange(actionBodyBlock.Statements.Skip(skipCount));
if (mc != null && mc.Postconditions.Any())
{
var assumes = from post in mc.Postconditions
select new AssumeStatement
{
Condition = post.Condition,
OriginalSource = post.OriginalSource,
Description = new CompileTimeConstant {
Value = "Inlined method postcondition", Type = host.PlatformType.SystemString
}
};
//Ponemos los assume antes del return
if (block.Statements.Count > 0 && block.Statements.Last() is IReturnStatement)
{
block.Statements.InsertRange(block.Statements.Count - 1, assumes);
}
else
{
block.Statements.AddRange(assumes);
}
}
return(block);
}
public IReadOnlyCollection <ActionQuery> CreateNegativeQueries(State state, Action action, IEnumerable <Action> actions)
{
var queryGenerator = new CciNegativeActionQueryGenerator(host);
return(CreateQueries(state, action, actions, queryGenerator));
}
