internal PersistedCredential(Guid userId, byte[] payload, byte[] token) { MethodContract.NotNull(payload, nameof(payload)); this.userId = userId; this.rawData = payload; this.rawToken = token; }
public CorsHandler(IHttpHandler next, CorsOptions options) { MethodContract.NotNull(next, nameof(next)); MethodContract.NotNull(options, nameof(options)); //lock it down so it can't change while in use this.options = new CorsOptions(); foreach (string cur in options.Origins) { this.options.Origins.Add(cur); } foreach (string cur in options.RequestHeaders) { this.options.RequestHeaders.Add(cur); } foreach (string cur in options.ResponseHeaders) { this.options.ResponseHeaders.Add(cur); } foreach (HttpVerbs cur in options.Verbs) { foreach (string v in CorsConstants.SimpleMethods) //short list, so not horrible esp. since we do this once per corshandler instance { this.hasNonSimpleVerbs = this.hasNonSimpleVerbs || v.Equals(cur.ToString()); } this.options.Verbs.Add(cur); } this.options.PreflightMaxAge = options.PreflightMaxAge; this.options.SupportsCredentials = options.SupportsCredentials; this.Next = next; }
public HttpListenerServerListener(IEnumerable <string> urls, IHttpHandler handler) : base() { MethodContract.NotNull(urls, nameof(urls)); MethodContract.NotNull(handler, nameof(handler)); foreach (string url in urls) { Uri x; MethodContract.Assert(Uri.TryCreate(url, UriKind.Absolute, out x), string.Format("{0} not a valid uri", nameof(urls))); MethodContract.Assert(x.Scheme == Uri.UriSchemeHttp || x.Scheme == Uri.UriSchemeHttps, string.Format("{0} not a valid http/https uri", nameof(urls))); if (url.EndsWith("/")) { this.urls.Add(url); } else { this.urls.Add(url + '/'); } } this.handler = handler; this.listener = new System.Net.HttpListener(); this.listener.AuthenticationSchemes = System.Net.AuthenticationSchemes.Anonymous; foreach (string uri in this.urls) { this.listener.Prefixes.Add(uri); } }
/// <summary> /// Replaces any MemberBindings of the form (this,x) in the methodContract with a method call where the method /// being called is P where x is a private field of the source type that has been marked as [ContractPublicPropertyName("P")]. /// </summary> /// <param name="targetType"></param> /// <param name="sourceType"></param> /// <param name="methodContract"></param> internal static void ReplacePrivateFieldsThatHavePublicProperties(TypeNode targetType, TypeNode sourceType, MethodContract methodContract, ContractNodes contractNodes ) { Contract.Requires(sourceType != null); Dictionary <Field, Method> field2Getter = new Dictionary <Field, Method>(); for (int i = 0, n = /*sourceType.Members == null ? 0 : */ sourceType.Members.Count; i < n; i++) { Field f = sourceType.Members[i] as Field; if (f == null) { continue; } string propertyName = HelperMethods.GetStringFromAttribute(f, ContractNodes.SpecPublicAttributeName); if (propertyName != null) { Property p = sourceType.GetProperty(Identifier.For(propertyName)); if (p != null) { field2Getter.Add(f, p.Getter); } } } if (0 < field2Getter.Count) { SubstitutePropertyGetterForField s = new SubstitutePropertyGetterForField(field2Getter); s.Visit(methodContract); } return; }
public UserPasswordCredential(string userName, string password) { MethodContract.NotNull(userName, nameof(userName)); MethodContract.NotNull(password, nameof(password)); this.userName = userName; this.password = password; }
//TODO -- allow insert of record with NULL taxa iff -> (lifestage==null, count==0, indMass==NaN, whole==0) public FishDiet(Guid id, Guid fishId, CompoundIdentity taxaId, string vialId, string gutsampleid, string lifestage, uint?count, float sampleMass, float indMass, uint?wholeAnimalsWeighed, string description) { MethodContract.Assert(!Guid.Empty.Equals(id), nameof(id)); MethodContract.Assert(!Guid.Empty.Equals(fishId), nameof(fishId)); //MethodContract.NotNullOrEmpty(taxaId, nameof(taxaId)); if (taxaId.IsNullOrEmpty()) { if (count.HasValue && count > 0) { throw new ArgumentException("for null taxa must have 0 or null count"); } } this.Identity = id; this.fishId = fishId; this.taxaId = taxaId; this.VialId = vialId; this.GutSampleId = gutsampleid; this.LifeStage = lifestage; this.Count = count; this.SampleMass = sampleMass; this.IndividualMass = indMass; this.WholeAnimalsWeighed = wholeAnimalsWeighed; this.Description = description; }
public static string GenerateSalt(int saltLength, char minChar, char maxChar, Random generator, ISet <int> suppressedChars) { MethodContract.Assert(minChar < maxChar, nameof(minChar) + " must be less than " + nameof(maxChar)); int min = (int)minChar; int max = (int)maxChar; char[] sb = new char[saltLength]; //buckets to fill HashSet <int> visited = new HashSet <int>(); //buckets visited int count = 0; int lastBucket = 0; int bucket = GetBucketIndex(visited, saltLength, lastBucket, generator.Next(1, (saltLength - count) + 1)); int cur; while (count < saltLength) { cur = generator.Next(min, max + 1); if (suppressedChars == null || !suppressedChars.Contains(cur)) { sb[bucket] = (char)cur; lastBucket = bucket; bucket = GetBucketIndex(visited, saltLength, lastBucket, generator.Next(1, (saltLength - count) + 1)); count++; } } return(new string(sb)); }
Expression IContractDeserializer.ParseContract (MethodContract mc, string text, ErrorNodeList errs) { Expression expression = null; currentMethodContract = mc; currentMethod = null; currentType = null; if (mc != null){ currentMethod = mc.DeclaringMethod; currentType = currentMethod.DeclaringType; } try{ Parser.ParseContract(this.assembly, text, out expression); }catch (Exception e){ ErrorNodeList eList = errs != null ? errs : this.ErrorList; if (eList != null){ #if OLDERRORS ErrorHandler eh = new ErrorHandler(eList); eh.HandleError(mc,System.Compiler.Error.GenericError,"Deserializer error: " + e.Message); #else this.assembly.MetadataImportErrors.Add(e); #endif } throw e; } return expression; }
public SimpleFileHandler(string localPath, IEnumerable <string> defaultFiles, MimeTypes mimeTypes, FileExtensions allowed, FileExtensions disallowed) : base() { MethodContract.NotNull(localPath, nameof(localPath)); MethodContract.NotNull(defaultFiles, nameof(defaultFiles)); MethodContract.NotNull(mimeTypes, nameof(mimeTypes)); this.mapper = new DirectoryMapper(localPath); this.mimeTypes = mimeTypes; if (defaultFiles != null) { foreach (string curFil in defaultFiles) { this.defaultFiles.Add(curFil); } } if (allowed != null) { this.allowedExtensions = allowed; } else { this.allowedExtensions = new FileExtensions(); } if (disallowed != null) { this.disallowedExtensions = disallowed; } else { this.disallowedExtensions = new FileExtensions(); } }
private static ContractConsistencyInfo ComputeExposureForMethod(Method m) { ContractConsistencyInfo ei = null; if (!cache.ContainsKey(m)) { ei = new ContractConsistencyInfo(); MethodContract contract = m.Contract; if (!m.ApplyDefaultContract && !m.IsPropertyGetter) { ei.Init(m, ei.requiresExposable, false); ei.Init(m, ei.ensuresExposable, false); ContractVisitor requiresVisitor = new ContractVisitor(ei.requiresExposable, m); // requiresVisitor.VisitMethodContract(contract); requiresVisitor.VisitRequiresList(contract.Requires); ContractVisitor ensuresVisitor = new ContractVisitor(ei.ensuresExposable, m); ensuresVisitor.VisitEnsuresList(contract.Ensures); } else { ei.Init(m, ei.requiresExposable, true); ei.Init(m, ei.ensuresExposable, true); } } else { ei = cache[m]; } return(ei); }
internal PersistedCredential(Guid userId, string payload, string token) { MethodContract.NotNull(payload, nameof(payload)); this.userId = userId; this.text = payload; this.textToken = token; }
public SingleServerTaskPool(IListener <T> listener, IHandler <T> handler, ServerTaskPoolOptions options) { MethodContract.NotNull(listener, nameof(listener)); MethodContract.NotNull(handler, nameof(handler)); MethodContract.NotNull(options, nameof(options)); Setup((Func <T>)listener.GetContext, (Action <T>)handler.Handle, options); }
public VegTreeSampleDTO(CompoundIdentity taxaUnitId, float dbh, string description) { MethodContract.NotNullOrEmpty(taxaUnitId, nameof(taxaUnitId)); this.TaxaUnitId = taxaUnitId; this.DiameterBreastHigh = dbh; this.Description = description; }
public FieldTeamMember(CompoundIdentity personId, CompoundIdentity fieldTeamMemberRoleId) { MethodContract.NotNull(personId, nameof(personId)); MethodContract.NotNull(fieldTeamMemberRoleId, nameof(fieldTeamMemberRoleId)); this.PersonId = personId; this.fieldTeamMemberRoleId = fieldTeamMemberRoleId; }
public VegHerbSampleDTO(CompoundIdentity taxaUnitId, float percentCover, string description) { MethodContract.NotNullOrEmpty(taxaUnitId, nameof(taxaUnitId)); this.TaxaUnitId = taxaUnitId; this.PercentCover = percentCover; this.Description = description; }
public ProjectStatusType(CompoundIdentity id, string name, string description) { MethodContract.NotNullOrEmpty(id, nameof(id)); MethodContract.NotNullOrEmpty(name, nameof(name)); this.Identity = id; this.name = name; this.Description = description; }
public SingleServerTaskPool(Func <T> listener, Action <T> handler, ServerTaskPoolOptions options) { MethodContract.NotNull(listener, nameof(listener)); MethodContract.NotNull(handler, nameof(handler)); MethodContract.NotNull(options, nameof(options)); Setup(listener, handler, options); }
public FieldTeamMemberRole(CompoundIdentity id, string name, string description) { MethodContract.NotNullOrEmpty(id, nameof(id)); MethodContract.NotNullOrEmpty(name, nameof(name)); this.Identity = id; this.name = name; this.Description = description; }
public VegShrubSampleDTO(CompoundIdentity taxaUnitId, string sizeClass, uint count, string description) { MethodContract.NotNullOrEmpty(taxaUnitId, nameof(taxaUnitId)); this.TaxaUnitId = taxaUnitId; this.SizeClass = sizeClass; this.Count = count; this.Description = description; }
internal HandoffEvent(Func <T> listener, Action <T> handler, int maxQueueSize) { MethodContract.NotNull(listener, nameof(listener)); MethodContract.NotNull(handler, nameof(handler)); MethodContract.Assert(maxQueueSize > 0, nameof(maxQueueSize)); this.listen = listener; this.handle = handler; this.maxQueueSize = maxQueueSize; }
public static TaskPool CreateScavengingTaskPool(Action toRun, TaskPoolOptions options) { MethodContract.NotNull(toRun, nameof(toRun)); ScavengingTaskPoolRunner runner = new ScavengingTaskPoolRunner(toRun); TaskPool pool = new TaskPool(runner.Run, options); runner.pool = pool; return(pool); }
internal KnownArchetype(CompoundIdentity id, string name, string description) { MethodContract.Assert(!id.IsNullOrEmpty(), nameof(id)); MethodContract.NotNullOrEmpty(name, nameof(name)); this.Id = id; this.name = name; this.Description = description; }
public Organization(CompoundIdentity id, string name, string description) { MethodContract.NotNull(id, nameof(id)); MethodContract.NotNullOrEmpty(name, nameof(name)); this.Identity = id; this.name = name; this.Description = description; }
private void SetContainingBlockForContracts() { MethodContract mc = this.Compilation.ContractProvider.GetMethodContractFor(this) as MethodContract; if (mc != null) { mc.SetContainingBlock(this); } }
public Person(CompoundIdentity id, string firstName, string lastName) { MethodContract.NotNullOrEmpty(id, nameof(id)); MethodContract.NotNullOrEmpty(firstName, nameof(firstName)); MethodContract.NotNullOrEmpty(lastName, nameof(lastName)); this.Identity = id; this.firstName = firstName; this.lastName = lastName; }
public virtual void VisitMethodContract(MethodContract node) { if (node == null) { return; } VisitRequiresList(node.Requires); VisitEnsuresList(node.Ensures); }
protected OrganizationHierarchy(CompoundIdentity identity, CompoundIdentity owningOrgId, string name, string description) { MethodContract.NotNullOrEmpty(identity, nameof(identity)); MethodContract.NotNullOrEmpty(owningOrgId, nameof(owningOrgId)); MethodContract.NotNullOrEmpty(name, nameof(name)); this.Identity = identity; this.owningOrgId = owningOrgId; this.name = name; this.Description = description; }
public TreeSampleDTO(Guid vegSampleId, VegTreeSampleDTO innerItem) { MethodContract.NotNull(innerItem, nameof(innerItem)); MethodContract.Assert(!Guid.Empty.Equals(vegSampleId), nameof(vegSampleId)); this.VegSampleId = vegSampleId; this.TaxaUnitId = innerItem.TaxaUnitId; this.DiameterBreastHigh = innerItem.DiameterBreastHigh; this.Description = innerItem.Description; }
public InstrumentArchetypeInstance(CompoundIdentity instrumentId, CompoundIdentity archetypeId, string data) { MethodContract.Assert(!InstrumentId.IsNullOrEmpty(), nameof(instrumentId)); MethodContract.Assert(!archetypeId.IsNullOrEmpty(), nameof(archetypeId)); MethodContract.NotNullOrEmpty(data, nameof(data)); this.InstrumentId = instrumentId; this.ArchetypeId = archetypeId; this.Data = data; }
public TreeSampleDTO(Guid vegSampleId, CompoundIdentity taxaUnitId, float dbh, string description) { MethodContract.NotNullOrEmpty(taxaUnitId, nameof(taxaUnitId)); MethodContract.Assert(!Guid.Empty.Equals(vegSampleId), nameof(vegSampleId)); this.VegSampleId = vegSampleId; this.TaxaUnitId = taxaUnitId; this.DiameterBreastHigh = dbh; this.Description = description; }
public SensorType(CompoundIdentity id, string name, string description, CompoundIdentity parentId) { MethodContract.Assert(!id.IsNullOrEmpty(), nameof(id)); MethodContract.NotNullOrEmpty(name, nameof(name)); this.Identity = id; this.name = name; this.Description = description; this.ParentId = parentId; }
public override MethodContract VisitMethodContract(MethodContract contract) { if (contract == null) return null; var savedCurrentMethod = this.CurrentMethod; this.CurrentMethod = contract.DeclaringMethod; try { return base.VisitMethodContract(contract); } finally { this.CurrentMethod = savedCurrentMethod; } }
public override MethodContract VisitMethodContract(MethodContract contract) { if (contract == null) return null; contract = (MethodContract)contract.Clone(); //^ assume this.TargetMethod != null; contract.DeclaringMethod = this.TargetMethod; contract.ensures = this.VisitEnsuresList(contract.ensures); contract.modifies = this.VisitExpressionList(contract.modifies); contract.requires = this.VisitRequiresList(contract.requires); return contract; }
/// <summary> /// TODO: figure out if there can be more than one closure initialization in a closureInitializer. /// Or other stuff. /// </summary> private static void DeleteClosureInitialization(Method containing, MethodContract mc, Local closureLocal) { Contract.Requires(containing != null); Contract.Requires(mc != null); Contract.Requires(closureLocal != null); var b = mc.ContractInitializer; mc.PostPreamble = null; bool foundStart = false; if (b == null || b.Statements == null || !(b.Statements.Count > 0)) { return; } for (int i = 0; i < b.Statements.Count; i++) { Statement s = b.Statements[i]; if (s == null || s.NodeType == NodeType.Nop) continue; if (s is Block) { // indicates code from an abbreviator call if (foundStart) { // this is the end return; } // skip the block continue; } Local otherLocal; if (IsClosureCreation(containing, s, out otherLocal)) { if (foundStart) { // this must be the next one return; } if (closureLocal == otherLocal) { foundStart = true; } } if (foundStart) { // delete b.Statements[i] = null; // delete } } }
/// <summary> /// Visits the specified method contract. /// </summary> /// <param name="methodContract">The method contract.</param> /// <returns></returns> protected virtual IMethodContract DeepCopy(MethodContract methodContract) { methodContract.Allocates = this.DeepCopy(methodContract.Allocates); methodContract.Frees = this.DeepCopy(methodContract.Frees); methodContract.ModifiedVariables = this.DeepCopy(methodContract.ModifiedVariables); methodContract.Postconditions = this.DeepCopy(methodContract.Postconditions); methodContract.Preconditions = this.DeepCopy(methodContract.Preconditions); methodContract.Reads = this.DeepCopy(methodContract.Reads); methodContract.ThrownExceptions = this.DeepCopy(methodContract.ThrownExceptions); methodContract.Writes = this.DeepCopy(methodContract.Writes); return methodContract; }
public virtual MethodContract VisitMethodContract(MethodContract contract){ if (contract == null) return null; // don't visit contract.DeclaringMethod // don't visit contract.OverriddenMethods contract.Requires = this.VisitRequiresList(contract.Requires); contract.Ensures = this.VisitEnsuresList(contract.Ensures); contract.Modifies = this.VisitExpressionList(contract.Modifies); return contract; }
private void RecordEnsures( Method method, ref int oldLocalUniqueNameCounter, List<Block> contractInitializationBlocks, Dictionary<TypeNode, Local> closureLocals, Block oldExpressionPreStateValues, List<Ensures> postconditions, List<Ensures> asyncPostconditions, WrapParametersInOldExpressions wrap, ref EmitAsyncClosure asyncBuilder, MethodContract mc) { RewriteHelper.RecordClosureInitialization(method, mc.ContractInitializer, closureLocals); if (this.Emit(RuntimeContractEmitFlags.Ensures) && mc.Ensures != null) { mc.Ensures = wrap.VisitEnsuresList(mc.Ensures); Block oldInits = ProcessOldExpressions(method, mc.Ensures, closureLocals, ref oldLocalUniqueNameCounter); if (oldInits != null) { oldExpressionPreStateValues.Statements.Add(oldInits); } if (mc.Ensures != null) { foreach (Ensures ensures in mc.Ensures) { if (!EmitEnsures(ensures, method.DeclaringType, this.skipQuantifiers)) continue; postconditions.Add(ensures); } } } if (this.Emit(RuntimeContractEmitFlags.AsyncEnsures) && mc.AsyncEnsuresCount > 0) { mc.AsyncEnsures = wrap.VisitEnsuresList(mc.AsyncEnsures); var found = false; foreach (Ensures postcondition in mc.AsyncEnsures) { if (!EmitEnsures(postcondition, method.DeclaringType, this.skipQuantifiers) || asyncPostconditions.Contains(postcondition)) continue; EnsureAsyncBuilder(method, contractInitializationBlocks, closureLocals, ref asyncBuilder); found = true; asyncPostconditions.Add(postcondition); } if (found) { Block oldInit = ProcessOldExpressionsInAsync(method, mc.AsyncEnsures, closureLocals, ref oldLocalUniqueNameCounter, asyncBuilder.ClosureClass); if (oldInit != null && oldInit.Statements != null && oldInit.Statements.Count > 0) { oldExpressionPreStateValues.Statements.Add(oldInit); } } } }
/// <summary> /// Replaces any MemberBindings of the form (this,x) in the methodContract with a method call where the method /// being called is P where x is a private field of the source type that has been marked as [ContractPublicPropertyName("P")]. /// </summary> /// <param name="targetType"></param> /// <param name="sourceType"></param> /// <param name="methodContract"></param> internal static void ReplacePrivateFieldsThatHavePublicProperties(TypeNode targetType, TypeNode sourceType, MethodContract methodContract, ContractNodes contractNodes ) { Contract.Requires(sourceType != null); Dictionary<Field, Method> field2Getter = new Dictionary<Field, Method>(); for (int i = 0, n = /*sourceType.Members == null ? 0 : */ sourceType.Members.Count; i < n; i++) { Field f = sourceType.Members[i] as Field; if (f == null) continue; string propertyName = HelperMethods.GetStringFromAttribute(f, ContractNodes.SpecPublicAttributeName); if (propertyName != null) { Property p = sourceType.GetProperty(Identifier.For(propertyName)); if (p != null) { field2Getter.Add(f, p.Getter); } } } if (0 < field2Getter.Count) { SubstitutePropertyGetterForField s = new SubstitutePropertyGetterForField(field2Getter); s.Visit(methodContract); } return; }
internal void CheckAbbreviatorEnsures(MethodContract methodContract) { if (methodContract == null) return; for (int i = 0; i < methodContract.EnsuresCount; i++) { var ens = methodContract.Ensures[i]; Contract.Assume(ens != null); Contract.Assume(methodContract.DeclaringMethod != null); // F: this.CheckEnsures(methodContract.DeclaringMethod, ens); } if (methodContract.ModelEnsuresCount > 0) { var modelEnsures = methodContract.ModelEnsures[0]; if (modelEnsures != null) { this.HandleError(methodContract.DeclaringMethod, 1074, "ContractAbbreviator methods cannot contain Ensures referring to Model members.", modelEnsures); } } }
internal void CheckEnsures(MethodContract contract) { if (contract == null) return; Contract.Assume(contract.DeclaringMethod != null); this.CurrentMethod = contract.DeclaringMethod; for (int i = 0; i < contract.EnsuresCount; i++) { var ens = contract.Ensures[i]; CheckPostcondition(ens); } for (int i = 0; i < contract.ModelEnsuresCount; i++) { var ens = contract.ModelEnsures[i]; CheckPostcondition(ens); } for (int i = 0; i < contract.AsyncEnsuresCount; i++) { var ens = contract.AsyncEnsures[i]; CheckPostcondition(ens); } }
public override void VisitMethodContract(MethodContract contract) { // don't visit again... }
private void CheckEnsures(MethodContract methodContract) { this.postconditionChecker.CheckEnsures(methodContract); }
private static bool HasValidations(MethodContract methodContract) { return methodContract != null && methodContract.HasLegacyValidations; }
internal static int ParseContract (Module assem, string text, out Expression expression) { Debug.Assert(assem != null); currentAssembly = assem; Scanner.Init(text); Errors.SynErr = new ErrorProc(SynErr); t = new Token(); Get(); Expr(out expression); currentMethodContract = null; currentMethod = null; currentAssembly = null; return Errors.count; }
public override MethodContract VisitMethodContract(MethodContract contract) { bool savedInsideAssertion = this.insideAssertion; this.insideAssertion = true; try { return base.VisitMethodContract(contract); } finally { this.insideAssertion = savedInsideAssertion; } }
public virtual MethodContract VisitMethodContract (MethodContract node) { if (node == null) return null; node.Requires = VisitRequiresList (node.Requires); node.Ensures = VisitEnsuresList (node.Ensures); return node; }
public virtual MethodContract VisitMethodContract(MethodContract contract1, MethodContract contract2) { if (contract1 == null) return null; if (contract2 == null) { // don't visit contract.DeclaringMethod // don't visit contract.OverriddenMethods contract1.Requires = this.VisitRequiresList(contract1.Requires, null); contract1.Ensures = this.VisitEnsuresList(contract1.Ensures, null); contract1.Modifies = this.VisitExpressionList(contract1.Modifies, null); }else{ // don't visit contract.DeclaringMethod // don't visit contract.OverriddenMethods contract1.Requires = this.VisitRequiresList(contract1.Requires,contract2.Requires); contract1.Ensures = this.VisitEnsuresList(contract1.Ensures,contract2.Ensures); contract1.Modifies = this.VisitExpressionList(contract1.Modifies,contract2.Modifies); } return contract1; }
public override MethodContract VisitMethodContract(MethodContract contract){ if (contract == null) return null; var specializer = this as MethodBodySpecializer; if (specializer == null) { specializer = contract.DeclaringMethod.DeclaringType.DeclaringModule.GetMethodBodySpecializer(this.pars, this.args); specializer.CurrentMethod = this.CurrentMethod; specializer.CurrentType = this.CurrentType; } contract.contractInitializer = specializer.VisitBlock(contract.contractInitializer); contract.postPreamble = specializer.VisitBlock(contract.postPreamble); contract.ensures = specializer.VisitEnsuresList(contract.ensures); contract.asyncEnsures = specializer.VisitEnsuresList(contract.asyncEnsures); contract.modelEnsures = specializer.VisitEnsuresList(contract.modelEnsures); contract.modifies = specializer.VisitExpressionList(contract.modifies); contract.requires = specializer.VisitRequiresList(contract.requires); return contract; }
public virtual void VisitMethodContract(MethodContract contract) { if (contract == null) return; // don't visit contract.DeclaringMethod // don't visit contract.OverriddenMethods this.VisitRequiresList(contract.Requires); this.VisitEnsuresList(contract.Ensures); this.VisitEnsuresList(contract.ModelEnsures); this.VisitExpressionList(contract.Modifies); this.VisitEnsuresList(contract.AsyncEnsures); }
internal static int ParseContract (Module assem, string text, out Expression expression) { Debug.Assert(assem != null); currentAssembly = assem; System.IO.MemoryStream ms = new System.IO.MemoryStream(Encoding.UTF8.GetBytes(text), false); Errors errors = new Errors(); Scanner scanner = new Scanner(ms, errors, ""); Parser parser = new Parser(scanner, errors); parser.Get(); parser.Expr(out expression); currentMethodContract = null; currentMethod = null; currentAssembly = null; if (parser.errors.count == 0) { return 0; } else { expression = null; return parser.errors.count; } }
private void CheckRequires(MethodContract methodContract) { this.preconditionChecker.CheckRequires(methodContract); this.visibilityChecker.CheckRequires(methodContract); }
public override MethodContract VisitMethodContract(MethodContract contract) { if (contract == null) return null; // don't visit contract.DeclaringMethod // don't visit contract.OverriddenMethods bool savedInsideMethodContract = this.insideMethodContract; bool savedUnsafe = this.typeSystem.insideUnsafeCode; this.insideMethodContract = true; Yield savedYield = this.yieldNode; Method method = contract.DeclaringMethod; insidePureContract = method.IsPure || method.IsConfined || method.IsStateIndependent; if (method != null) { this.typeSystem.insideUnsafeCode = method.IsUnsafe; if (contract.Ensures != null && contract.Ensures.Count > 0) { TrivialHashtable /*TypeNode*/ throwsSet = new TrivialHashtable(); for (int i = 0, n = contract.Ensures.Count; i < n; i++) { EnsuresExceptional e = contract.Ensures[i] as EnsuresExceptional; if (e == null) continue; if (e.Inherited) continue; if (e.Type == null) continue; if (!this.GetTypeView(e.Type).IsAssignableTo(SystemTypes.ICheckedException)) { this.HandleError(e, Error.UncheckedExceptionInThrowsClause, this.GetTypeName(method.DeclaringType) + "." + method.Name.ToString()); contract.Ensures[i] = null; } if (throwsSet[e.Type.UniqueKey] != null) { this.HandleError(method, Error.DuplicateThrowsType, this.GetTypeName(method.DeclaringType) + "." + method.Name.ToString()); contract.Ensures[i] = null; } else { throwsSet[e.Type.UniqueKey] = e.Type; } } } contract.Requires = this.VisitRequiresList(contract.Requires); InstanceInitializer ctor = this.currentMethod as InstanceInitializer; bool savedMayReferenceThisAndBase = this.MayReferenceThisAndBase; if (ctor != null) { // method contracts are visited as part of visiting the methods to which they // are attached. So their ability to reference "this" is usually the same as // the method's ability. But the postcondition of a ctor can mention instance // variables. this.MayReferenceThisAndBase = true; } bool savedInsideEnsures = this.insideEnsures; this.insideEnsures = true; contract.Ensures = this.VisitEnsuresList(contract.Ensures); this.insideEnsures = savedInsideEnsures; this.MayReferenceThisAndBase = savedMayReferenceThisAndBase; bool savedInsideModifies = this.insideModifies; this.insideModifies = true; contract.Modifies = this.VisitExpressionList(contract.Modifies); this.insideModifies = savedInsideModifies; //if (method.IsVirtual) { // // use FindNearest..., can't rely on method.OverriddenMethod since it might not be set further up the chain // Method overridden = method.DeclaringType.FindNearestOverriddenMethod(method); // if (overridden != null) { // this.CheckEnsuresListsCompatibility(overridden, method); // } // for (int i = 0, n = method.ImplementedInterfaceMethods == null ? 0 : method.ImplementedInterfaceMethods.Count; i < n; i++) { // Method ifaceMethod = method.ImplementedInterfaceMethods[i]; // this.CheckEnsuresListsCompatibility(ifaceMethod, method); // } // for (int i = 0, n = method.ImplicitlyImplementedInterfaceMethods == null ? 0 : method.ImplicitlyImplementedInterfaceMethods.Count; i < n; i++) { // Method ifaceMethod = method.ImplicitlyImplementedInterfaceMethods[i]; // this.CheckEnsuresListsCompatibility(ifaceMethod, method); // } //} } this.insideMethodContract = savedInsideMethodContract; this.typeSystem.insideUnsafeCode = savedUnsafe; this.yieldNode = savedYield; return contract; }
private static bool HasNonValidationContract(MethodContract methodContract) { if (methodContract == null) return false; return methodContract.EnsuresCount > 0 || Contract.Exists(0, methodContract.RequiresCount, i => !((RequiresPlain) methodContract.Requires[i]).IsFromValidation); }
// TODO: otherwise clauses on requires, exceptional ensures public virtual void SerializeMethodContract(MethodContract mc) { if (mc.Requires != null) { for (int i = 0, n = mc.Requires.Count; i < n; i++) { Requires r = mc.Requires[i]; if (r == null || r.Condition == null || r.Inherited) continue; ExpressionList el = SplitConjuncts(r.Condition); for (int j = 0, m = el.Count; j < m; j++) { Requires r_prime = new RequiresPlain(el[j]); InstanceInitializer ctor = SystemTypes.RequiresAttribute.GetConstructor(SystemTypes.String); AttributeNode a = Checker.SerializeExpression(ctor, r_prime.Condition, this.currentModule); mc.DeclaringMethod.Attributes.Add(a); } } } if (mc.Ensures != null) { for (int i = 0, n = mc.Ensures.Count; i < n; i++) { EnsuresExceptional ee = mc.Ensures[i] as EnsuresExceptional; if (ee != null) { if (ee.PostCondition == null) { if (ee.Inherited || ee.TypeExpression.SourceContext.Document == null) continue; // then it is "throws E;" InstanceInitializer ctor = SystemTypes.ThrowsAttribute.GetConstructor(SystemTypes.Type); AttributeNode a = Checker.SerializeExpressions(ctor, new ExpressionList(new Literal(ee.Type, SystemTypes.Type)), null, ee.TypeExpression.SourceContext, this.currentModule); mc.DeclaringMethod.Attributes.Add(a); } else { // then it is "throws E ensures Q;" or "throws (E e) ensures Q;" // don't split Q into its top-level conjuncts because duplicate throws clauses for the same exception type // are not allowed. if (ee.Inherited || ee.PostCondition.SourceContext.Document == null) continue; InstanceInitializer ctor = SystemTypes.ThrowsAttribute.GetConstructor(SystemTypes.Type, SystemTypes.String); AttributeNode a = Checker.SerializeExpressions(ctor, new ExpressionList(new Literal(ee.Type, SystemTypes.Type)), new ExpressionList(ee.PostCondition), ee.PostCondition.SourceContext, this.currentModule); mc.DeclaringMethod.Attributes.Add(a); } } else { Ensures e = mc.Ensures[i]; if (e == null || e.PostCondition == null || e.Inherited || e.PostCondition.SourceContext.Document == null) continue; ExpressionList el = SplitConjuncts(e.PostCondition); for (int j = 0, m = el.Count; j < m; j++) { EnsuresNormal e_prime = new EnsuresNormal(el[j]); InstanceInitializer ctor = SystemTypes.EnsuresAttribute.GetConstructor(SystemTypes.String); AttributeNode a = Checker.SerializeExpression(ctor, e_prime.PostCondition, this.currentModule); mc.DeclaringMethod.Attributes.Add(a); } } } } if (mc.Modifies != null && mc.Modifies.Count > 0) { for (int i = 0, n = mc.Modifies.Count; i < n; i++) { Expression e = mc.Modifies[i]; if (e == null || e.SourceContext.Document == null) continue; InstanceInitializer ctor = SystemTypes.ModifiesAttribute.GetConstructor(SystemTypes.String); AttributeNode a = Checker.SerializeExpression(ctor, e, this.currentModule); mc.DeclaringMethod.Attributes.Add(a); } } return; }
internal void CheckRequires(MethodContract contract) { if (contract == null) return; this.CurrentMethod = contract.DeclaringMethod; var requiresList = contract.Requires; if (requiresList == null) return; foreach (var req in requiresList) { CheckPrecondition(req); } }
public virtual void VisitMethodContract (MethodContract node) { if (node == null) return; VisitRequiresList (node.Requires); VisitEnsuresList (node.Ensures); }
/// <summary> /// If the method contract is for an interface/abstract type, we need to make sure we use the visibility of the target method, not the contract method. /// </summary> internal void CheckRequires(MethodContract methodContract) { if (methodContract == null || methodContract.Requires == null) return; // F: Contract.Assume(methodContract.DeclaringMethod != null); Method targetMethod = FindTargetMethod(methodContract.DeclaringMethod); foreach (var req in methodContract.Requires) { Contract.Assume(req != null); //F: this.CheckRequires(targetMethod, req); } }
/// <summary> /// A copy constructor that allocates an instance that is the same as the given template. /// </summary> /// <param name="template">The template to copy.</param> protected MethodContract(MethodContract template) { if (template.allocates != EmptyListOfExpressions) this.allocates = new List<Expression>(template.allocates); else this.allocates = template.allocates; if (template.frees != EmptyListOfExpressions) this.frees = new List<Expression>(template.frees); else this.frees = template.frees; if (template.modifiedVariables != EmptyListOfTargetExpressions) this.modifiedVariables = new List<AddressableExpression>(template.modifiedVariables); else this.modifiedVariables = template.modifiedVariables; this.mustInline = template.mustInline; if (template.postconditions != EmptyListOfPostconditions) this.postconditions = new List<Postcondition>(template.postconditions); else this.postconditions = template.postconditions; if (template.preconditions != EmptyListOfPreconditions) this.preconditions = new List<Precondition>(template.preconditions); else this.preconditions = template.preconditions; if (template.reads != EmptyListOfExpressions) this.reads = new List<Expression>(template.reads); else this.reads = template.reads; if (template.thrownExceptions != EmptyListOfThrownExceptions) this.thrownExceptions = new List<ThrownException>(template.thrownExceptions); else this.thrownExceptions = template.thrownExceptions; if (template.writes != EmptyListOfExpressions) this.writes = new List<Expression>(template.writes); else this.writes = template.writes; if (template.variants != EmptyListOfExpressions) this.variants = new List<Expression>(template.variants); else this.variants = template.variants; this.isPure = template.isPure; }
private void CheckMethodContract(MethodContract contract) { if (contract == null) return; this.CheckRequires(contract); this.CheckEnsures(contract); }
/// <summary> /// Makes a copy of this contract, changing the containing block to the given block. /// </summary> //^ [MustOverride] public virtual MethodContract MakeCopyFor(BlockStatement containingBlock) { if (this.containingBlock == containingBlock) return this; MethodContract result = new MethodContract(this); result.SetContainingBlock(containingBlock); return result; }