Declarative Annotations for Logic Programs

A type system is a useful addition to a logic programming language as it makes numerous program errors visible at compile time rather than at run time. This greatly reduces the time taken for many errors to become manifest, identified and hence to be corrected. Type declarations may be viewed as expressing aspects of a programmer's intent for their code and are analysed as part of the compilation process. We extend this view here, describing a set of user-defined annotations which permit programmers to express other parts of their intended interpretation for programs in a manner amenable to static analysis. Such annotations increase both the number and variety of errors in logic programs which are captured at compile time

These annotations, and the static analysis tools which test them, are implemented in the declarative logic programming language Gödel. Gödel provides a number of facilities which may he exploited by the annotations, most notably types, control declarations and a lack of non-logical features. Gódel's substantial support for declarative meta-programming also make it an interesting implementation language for the analysis tools. However, our annotations, with the exception of those which build directly on Gödel's type system, are equally applicable to other logic programming languages

We seek to capture errors which may be classified s.s discrepancies between programmers intention and actual code. While many such errors are purely syntactic in nature, such as formulas which are ill-formed or ill-typed, others are semantic in nature, in that the code as written does not match what the programmer intends. Annotations seek to capture the latter. Annotations fall into two classes: those for arguments of a predicate and those for the predicate as a whole. Argument annotations may declare information concerning the domain of a particular argument and may declare pairs of arguments to be accumulators. Predicate declarations may declare that predicates are, for example, terminating or determinate. Annotations support programmers in a fashion which requires little or no alteration to any current programming methodology and may be applied retrospectively to a completed program. In addition, the programmer can select their own level of detail in providing annotations. This supports an approach to verifiable documentation which is closer to most actual code development, rather than an idealised view of automated development from some complete and verified specification