lib/typecheck/TypeCheck.h

Go to the documentation of this file.

//===-- typecheck/TypeCheck.h --------------------------------- -*- C++ -*-===//
//
// This file is distributed under the MIT license.  See LICENSE.txt for details.
//
// Copyright (C) 2008-2010, Stephen Wilson
//
//===----------------------------------------------------------------------===//

#ifndef COMMA_TYPECHECK_TYPECHECK_HDR_GUARD
#define COMMA_TYPECHECK_TYPECHECK_HDR_GUARD


#include "Scope.h"
#include "Stencil.h"
#include "comma/ast/AstBase.h"
#include "comma/ast/AstResource.h"
#include "comma/ast/Cunit.h"
#include "comma/ast/Type.h"
#include "comma/basic/Diagnostic.h"
#include "comma/basic/TextProvider.h"
#include "comma/typecheck/Checker.h"

#include "llvm/Support/Casting.h"

#include <stack>

namespace llvm {

class APInt;

} // end llvm namespace.

namespace comma {

class TypeCheck : public Checker {

public:
    TypeCheck(Diagnostic      &diag,
              AstResource     &resource,
              CompilationUnit *cunit);

    ~TypeCheck();


    void beginCapsule();
    void endCapsule();

    void beginGenericFormals();
    void endGenericFormals();

    void acceptFormalDomain(IdentifierInfo *name, Location loc, Node sig);

    void beginDomainDecl(IdentifierInfo *name, Location loc);
    void beginSignatureDecl(IdentifierInfo *name, Location loc);

    void beginSignatureProfile();
    void endSignatureProfile();

    void acceptSupersignature(Node typeNode);

    void beginAddExpression();
    void endAddExpression();

    void acceptCarrier(IdentifierInfo *name, Location loc, Node typeNode);

    void beginFunctionDeclaration(IdentifierInfo *name, Location loc);
    void beginProcedureDeclaration(IdentifierInfo *name, Location loc);


    void acceptSubroutineParameter(IdentifierInfo *formal, Location loc,
                                   Node typeNode, PM::ParameterMode mode);

    void acceptFunctionReturnType(Node typeNode);

    Node endSubroutineDeclaration(bool definitionFollows);

    Node beginSubroutineDefinition(Node declarationNode);
    void endSubroutineBody(Node contextNode);
    void endSubroutineDefinition();

    Node acceptDirectName(IdentifierInfo *name, Location loc,
                          bool forStatement);

    Node acceptCharacterLiteral(IdentifierInfo *lit, Location loc);

    Node acceptSelectedComponent(Node prefix,
                                 IdentifierInfo *name,
                                 Location loc,
                                 bool forStatement);

    Node acceptParameterAssociation(IdentifierInfo *key,
                                    Location loc, Node rhs);

    Node acceptApplication(Node prefix, NodeVector &argNodes);

    Node acceptAttribute(Node prefix, IdentifierInfo *name, Location loc);

    Node finishName(Node name);

    void beginAggregate(Location loc);
    void acceptPositionalAggregateComponent(Node component);
    Node acceptAggregateKey(Node lower, Node upper);
    Node acceptAggregateKey(IdentifierInfo *name, Location loc);
    Node acceptAggregateKey(Node key);
    void acceptKeyedAggregateComponent(NodeVector &keys,
                                       Node expr, Location loc);
    void acceptAggregateOthers(Location loc, Node component);
    Node endAggregate();

    Node beginForStmt(Location loc, IdentifierInfo *iterName, Location iterLoc,
                      Node control, bool isReversed);
    Node endForStmt(Node forNode, NodeVector &bodyNodes);

    Node acceptDSTDefinition(Node name, Node lower, Node upper);
    Node acceptDSTDefinition(Node nameOrAttribute, bool isUnconstrained);
    Node acceptDSTDefinition(Node lower, Node upper);

    bool acceptObjectDeclaration(Location loc, IdentifierInfo *name,
                                 Node type, Node initializer);

    bool acceptRenamedObjectDeclaration(Location loc, IdentifierInfo *name,
                                        Node type, Node target);

    void acceptDeclarationInitializer(Node declNode, Node initializer);

    Node acceptPercent(Location loc);

    bool acceptImportDeclaration(Node importedType);

    Node acceptProcedureCall(Node name);

    Node acceptInj(Location loc, Node expr);

    Node acceptPrj(Location loc, Node expr);

    Node acceptIntegerLiteral(llvm::APInt &value, Location loc);

    Node acceptStringLiteral(const char *string, unsigned len, Location loc);

    Node acceptNullExpr(Location loc);

    Node acceptAllocatorExpr(Node operand, Location loc);

    Node acceptQualifiedExpr(Node qualifier, Node operand);

    Node acceptDereference(Node prefix, Location loc);

    Node acceptIfStmt(Location loc, Node condition, NodeVector &consequents);

    Node acceptElseStmt(Location loc, Node ifNode, NodeVector &alternates);

    Node acceptElsifStmt(Location loc, Node ifNode, Node condition,
                         NodeVector &consequents);

    Node acceptEmptyReturnStmt(Location loc);

    Node acceptReturnStmt(Location loc, Node retNode);

    Node acceptAssignmentStmt(Node target, Node value);

    Node beginBlockStmt(Location loc, IdentifierInfo *label = 0);
    void endBlockStmt(Node block);

    Node beginHandlerStmt(Location loc, NodeVector &choices);
    void endHandlerStmt(Node context, Node handler);

    Node acceptNullStmt(Location loc);

    bool acceptStmt(Node context, Node stmt);

    Node acceptWhileStmt(Location loc, Node condition, NodeVector &stmtNodes);

    Node acceptLoopStmt(Location loc, NodeVector &stmtNodes);

    Node acceptRaiseStmt(Location loc, Node exception, Node message);

    Node acceptPragmaStmt(IdentifierInfo *name, Location loc, NodeVector &args);

    void acceptPragmaImport(Location pragmaLoc,
                            IdentifierInfo *convention, Location conventionLoc,
                            IdentifierInfo *entity, Location entityLoc,
                            Node externalNameNode);

    void beginEnumeration(IdentifierInfo *name, Location loc);
    void acceptEnumerationIdentifier(IdentifierInfo *name, Location loc);
    void acceptEnumerationCharacter(IdentifierInfo *name, Location loc);
    void endEnumeration();

    void acceptIntegerTypeDecl(IdentifierInfo *name, Location loc,
                               Node low, Node high);

    void acceptRangedSubtypeDecl(IdentifierInfo *name, Location loc,
                                 Node subtype, Node low, Node high);

    void acceptSubtypeDecl(IdentifierInfo *name, Location loc, Node subtype);
    void acceptIncompleteTypeDecl(IdentifierInfo *name, Location loc);
    void acceptAccessTypeDecl(IdentifierInfo *name, Location loc, Node subtype);

    void acceptArrayDecl(IdentifierInfo *name, Location loc,
                         NodeVector indices, Node component);

    void beginRecord(IdentifierInfo *name, Location loc);
    void acceptRecordComponent(IdentifierInfo *name, Location loc, Node type);
    void endRecord();

    // Delete the underlying Ast node.
    void deleteNode(Node &node);



    bool checkSuccessful() const { return diagnostic.numErrors() == 0; }

    CompilationUnit *getCompilationUnit() const { return compUnit; }

    Diagnostic &getDiagnostic() { return diagnostic; }

    AstResource &getAstResource() { return resource; }



    static bool conversionRequired(Type *source, Type *target);

    static Expr *convertIfNeeded(Expr *expr, Type *target);

    Type *getCoveringDereference(Type *source, Type *target);

    Type *getCoveringDereference(Type *source, Type::Classification ID);

    Expr *implicitlyDereference(Expr *expr, Type *target);

    Expr *implicitlyDereference(Expr *expr, Type::Classification ID);

    Expr *checkExprInContext(Expr *expr, Type *context);

    bool checkExprInContext(Expr *expr, Type::Classification ID);

    Expr *checkExprAndDereferenceInContext(Expr *expr, Type *context);

    bool ensureStaticIntegerExpr(Expr *expr, llvm::APInt &result);

    bool ensureStaticIntegerExpr(Expr *expr);

    Expr *ensureExpr(Node node);

    Expr *ensureExpr(Ast *node);

    Ast *checkDirectName(IdentifierInfo *name, Location loc, bool forStatement);

    static bool covers(Type *A, Type *B);

private:
    Diagnostic      &diagnostic;
    AstResource     &resource;
    CompilationUnit *compUnit;
    DeclRegion      *declarativeRegion;
    ModelDecl       *currentModel;
    Scope            scope;

    llvm::SmallVector<AbstractDomainDecl *, 8> GenericFormalDecls;

    EnumDeclStencil enumStencil;
    SRDeclStencil routineStencil;

    std::stack<AggregateExpr*> aggregateStack;

    template <class T>
    struct SVImpl {
        typedef llvm::SmallVectorImpl<T> Type;
    };

    //===------------------------------------------------------------------===//
    // Utility functions.
    //===------------------------------------------------------------------===//

    // Converts a Node to the corresponding Ast type.  If the node is not of the
    // supplied type, this function returns 0.
    template <class T>
    static T *lift_node(Node &node) {
        return llvm::dyn_cast_or_null<T>(Node::lift<Ast>(node));
    }

    // Casts the given Node to the corresponding type and asserts that the
    // conversion was successful.
    template <class T>
    static T *cast_node(Node &node) {
        return llvm::cast<T>(Node::lift<Ast>(node));
    }

    // A function object version of lift_node.
    template <class T>
    struct NodeLifter : public std::unary_function<Node&, T*> {
        T* operator ()(Node &node) const { return lift_node<T>(node); }
    };

    // A function object version of cast_node.
    template <class T>
    struct NodeCaster : public std::unary_function<Node&, T*> {
        T* operator ()(Node &node) const { return cast_node<T>(node); }
    };

    DeclRegion *currentDeclarativeRegion() const {
        return declarativeRegion;
    }

    void pushDeclarativeRegion(DeclRegion *region) {
        declarativeRegion = region;
    }

    DeclRegion *popDeclarativeRegion() {
        DeclRegion *res = declarativeRegion;
        declarativeRegion = res->getParent();
        return res;
    }

    CompilationUnit *currentCompUnit() const { return compUnit; }

    ModelDecl *getCurrentModel() const {
        return currentModel;
    }

    // If we are processing a Sigoid, return the current model cast to a
    // Sigoid, else 0.
    Sigoid *getCurrentSigoid() const;

    // If we are processing a Signature, return the current model cast to a
    // SignatureDecl, else 0.
    SignatureDecl *getCurrentSignature() const;

    // If we are processing a Variety, return the current model cast to a
    // VarietyDecl, else 0.
    VarietyDecl *getCurrentVariety() const;

    // If we are processing a Domoid, return the current model cast to a
    // Domoid, else 0.
    Domoid *getCurrentDomoid() const;

    // If we are processing a Domain, return the current model cast to a
    // DomainDecl, else 0.
    DomainDecl *getCurrentDomain() const;

    // If we are processing a Functor, return the current model cast to a
    // FunctorDecl, else 0.
    FunctorDecl *getCurrentFunctor() const;

    // If we are processing a subroutine, return the current SubroutineDecl,
    // else 0.
    SubroutineDecl *getCurrentSubroutine() const;

    // If we are processing a procedure, return the current ProcedureDecl, else
    // 0.
    ProcedureDecl *getCurrentProcedure() const;

    // If we are processing a function, return the current FunctionDecl, else 0.
    FunctionDecl *getCurrentFunction() const;

    // Returns the type of % for the current model, or 0 if we are not currently
    // processing a model.
    DomainType *getCurrentPercentType() const;

    // Returns the % node for the current model, or 0 if we are not currently
    // processing a model.
    PercentDecl *getCurrentPercent() const;

    // Returns true if we are currently checking a domain.
    bool checkingDomain() const { return getCurrentDomain() != 0; }

    // Returns true if we are currently checking a functor.
    bool checkingFunctor() const { return getCurrentFunctor() != 0; }

    // Returns true if we are currently checking a signature.
    bool checkingSignature() const { return getCurrentSignature() != 0; }

    // Returns true if we are currently checking a variety.
    bool checkingVariety() const { return getCurrentVariety() != 0; }

    // Returns true if we are currently checking a procedure.
    bool checkingProcedure() const { return getCurrentProcedure() != 0; }

    // Returns true if we are currently checking a function.
    bool checkingFunction() const { return getCurrentFunction() != 0; }

    // Called when then type checker is constructed.  Populates the top level
    // scope with the default environment specified by Comma (declarations of
    // primitive types like Boolean, for example).
    void populateInitialEnvironment();

    void initializeForModelDeclaration();

    bool compatibleSubroutineDecls(SubroutineDecl *X, SubroutineDecl *Y);

    bool ensureNonRecursiveInstance(FunctorDecl *decl,
                                    DomainTypeDecl **args, unsigned numArgs,
                                    Location loc);

    void acquireImplicitDeclarations(Decl *decl);

    void acquireSignatureDeclarations(SigInstanceDecl *sig, Location loc);

    TypeDecl *ensureCompleteTypeDecl(Node refNode, bool report = true);

    TypeDecl *ensureCompleteTypeDecl(Decl *decl, Location loc,
                                     bool report = true);

    TypeDecl *ensureTypeDecl(Decl *decl, Location loc, bool report = true);

    TypeDecl *ensureTypeDecl(Node refNode, bool report = true);

    Type *resolveType(Type *type) const;

    Type *resolveType(Expr *expr) const { return resolveType(expr->getType()); }

    // Resolves the type of the given integer literal, and ensures that the
    // given type context is itself compatible with the literal provided.
    // Returns a valid expression node (possibly different from \p intLit) if
    // the literal was successfully checked.  Otherwise, null is returned and
    // appropriate diagnostics are posted.
    Expr *resolveIntegerLiteral(IntegerLiteral *intLit, Type *context);

    // Resolved the type of the given integer literal with respect to the given
    // type classification.  Returns true if the literal was successfully
    // checked.  Otherwise false is returned and appropriate diagnostics are
    // posted.
    bool resolveIntegerLiteral(IntegerLiteral *intLit, Type::Classification ID);

    // Resolves the type of the given string literal, and ensures that the given
    // type context is itself compatible with the literal provided.  Returns a
    // valid expression if the literal was successfully checked (possibly
    // different from \p strLit).  Otherwise, null is returned and appropriate
    // diagnostics are posted.
    Expr *resolveStringLiteral(StringLiteral *strLit, Type *context);

    // Resolves the type of the an aggregate expression with respect to the
    // given type context.  Returns a valid expression if the aggregate was
    // successfully checked (possibly different from \p agg).  Otherwise, null
    // is returned and appropriate diagnostics are posted.
    Expr *resolveAggregateExpr(AggregateExpr *agg, Type *context);

    // Resolves a null expression if possible given a target type.  Returns a
    // valid expression node if \p expr was found to be compatible with \p
    // context.  Otherwise null is returned and diagnostics are posted.
    Expr *resolveNullExpr(NullExpr *expr, Type *context);

    // Resolves an allocator expression with respect to the given target type.
    // Returns a valid expression node on success and null otherwise.
    Expr *resolveAllocatorExpr(AllocatorExpr *alloc, Type *context);

    // Resolves a selected component expression with respect to the given target
    // type.
    Expr *resolveSelectedExpr(SelectedExpr *select, Type *context);

    // Resolves a diamond expression to the given target type.
    Expr *resolveDiamondExpr(DiamondExpr *diamond, Type *context);

    // Resolves the given call expression to one which satisfies the given
    // target type.  Returns a valid expression if the call was successfully
    // checked (possibly different from \p call).  Otherwise, null is returned
    // and the appropriate diagnostics are emitted.
    Expr *resolveFunctionCall(FunctionCallExpr *call, Type *type);

    // Resolves the given call expression to one which satisfies the given type
    // classification and returns true.  Otherwise, false is returned and the
    // appropriate diagnostics are emitted.
    bool resolveFunctionCall(FunctionCallExpr *call, Type::Classification ID);

    // Resolves the given call expression to one which returns a record type
    // that in turn provides a component with the given name and type.  Returns
    // a valid expression if the call was successfully resolved (possibly
    // different from \p call).  Otherwise, null is returned and diagnostics are
    // posted.
    Expr *resolveFunctionCall(FunctionCallExpr *call, IdentifierInfo *selector,
                              Type *targetType);

    // Returns the prefered connective for the given ambiguous function call, or
    // null if no unambiguous interpretation exists.
    FunctionDecl *resolvePreferredConnective(FunctionCallExpr *Call,
                                             Type *targetType);

    // Checks if the given set of function declarations contains a preferred
    // primitive operator which should be preferred over any other.  Returns the
    // prefered declaration if found and null otherwise.
    FunctionDecl *resolvePreferredOperator(SVImpl<FunctionDecl*>::Type &decls);

    Ast *acceptSubroutineApplication(SubroutineRef *ref,
                                     NodeVector &argNodes);

    bool checkSubroutineArgumentNodes(NodeVector &argNodes,
                                      SVImpl<Expr*>::Type &positional,
                                      SVImpl<KeywordSelector*>::Type &keyed);

    Expr *checkSubroutineArgument(Expr *arg, Type *targetType,
                                  PM::ParameterMode targetMode);

    bool checkSubroutineCallArguments(SubroutineCall *call);

    bool checkSubroutineArguments(SubroutineDecl *decl,
                                  SVImpl<Expr*>::Type &posArgs,
                                  SVImpl<KeywordSelector*>::Type &keyArgs);

    bool routineAcceptsArgs(SubroutineDecl *decl,
                            SVImpl<Expr*>::Type &args);

    bool routineAcceptsArgs(SubroutineDecl *decl,
                            SVImpl<KeywordSelector*>::Type &args);

    Ast *acceptSubroutineCall(SubroutineRef *ref,
                              SVImpl<Expr*>::Type &positionalArgs,
                              SVImpl<KeywordSelector*>::Type &keyedArgs);

    SubroutineCall *
    checkSubroutineCall(SubroutineRef *ref,
                        SVImpl<Expr*>::Type &positionalArgs,
                        SVImpl<KeywordSelector*>::Type &keyArgs);


    bool checkApplicableArgument(Expr *expr, Type *targetType);

    // Returns true if the given type is compatible with the given abstract
    // domain decl in the environment established by the given rewrites.
    //
    // In this case, the source must denote a domain which satisfies the entire
    // signature profile of the target.  The supplied location indicates the
    // position of the source type.
    bool checkSignatureProfile(const AstRewriter &rewrites, Type *source,
                               AbstractDomainDecl *target, Location loc);

    // Verifies that the given AddDecl satisfies the constraints imposed by its
    // signature.  Returns true if the constraints are satisfied.  Otherwise,
    // false is returned and diagnostics are posted.
    bool ensureExportConstraints(AddDecl *add);

    // Returns true if the given decl is equivalent to % in the context of the
    // current domain.
    bool denotesDomainPercent(const Decl *decl);

    // Returns true if we are currently checking a functor, and if the given
    // functor declaration together with the provided arguments would denote an
    // instance which is equivalent to % in the current context.  For example,
    // given:
    //
    //   domain F (X : T) with
    //      procedure Foo (A : F(X));
    //      ...
    //
    // Then "F(X)" is equivalent to %.  More generally, a functor F applied to
    // its formal arguments in the body of F is equivalent to %.
    //
    // This function assumes that the number and types of the supplied arguments
    // are compatible with the given functor.
    bool denotesFunctorPercent(const FunctorDecl *functor,
                               DomainTypeDecl **args, unsigned numArgs);

    SigInstanceDecl *resolveFormalSignature(ModelDecl *parameterizedModel,
                                            Type **arguments,
                                            unsigned numArguments);

    bool checkFunctionParameter(ParamValueDecl *param);

    bool acceptEnumerationLiteral(IdentifierInfo *name, Location loc);

    void introduceImplicitDecls(DeclRegion *region);

    TypeRef *buildTypeRefForModel(Location loc, ModelDecl *mdecl);

    Ast *checkIndirectName(Location loc, Resolver &resolver);

    TypeRef *acceptTypeApplication(TypeRef *ref, NodeVector &argNodes);

    TypeRef *acceptTypeApplication(TypeRef *ref,
                                   SVImpl<TypeRef *>::Type &posArgs,
                                   SVImpl<KeywordSelector *>::Type &keyedArgs);

    bool checkTypeArgumentNodes(NodeVector &argNodes,
                                SVImpl<TypeRef*>::Type &positional,
                                SVImpl<KeywordSelector*>::Type &keyed);

    DomainTypeDecl *ensureValidModelParam(TypeRef *ref);

    bool checkModelKeywordArgs(ModelDecl *model, unsigned numPositional,
                               SVImpl<KeywordSelector*>::Type &keyedArgs);

    bool checkModelArgs(ModelDecl *model,
                        SVImpl<DomainTypeDecl*>::Type &args,
                        SVImpl<Location>::Type &argLocs);

    bool introduceTypeDeclaration(TypeDecl *decl);

    IndexedArrayExpr *acceptIndexedArray(Expr *ref, NodeVector &argNodes);

    bool checkArrayIndexNodes(NodeVector &argNodes,
                              SVImpl<Expr*>::Type &indices);

    IndexedArrayExpr *acceptIndexedArray(Expr *ref,
                                         SVImpl<Expr*>::Type &indices);

    ObjectDecl *acceptArrayObjectDeclaration(Location loc, IdentifierInfo *name,
                                             ArrayDecl *arrDecl, Expr *init);

    ArrayType *getConstrainedArraySubtype(ArrayType *arrTy, Expr *init);

    Ast *finishSubroutineRef(SubroutineRef *ref);

    bool finishTypeRef(TypeRef *ref);

    Ast *processExpandedName(TypeRef *ref, IdentifierInfo *name, Location loc,
                             bool forStatement);

    Ast *processSelectedComponent(Expr *expr, IdentifierInfo *name,
                                  Location loc, bool forStatement);

    PragmaAssert *acceptPragmaAssert(Location loc, NodeVector &args);

    Ast *checkAttribute(attrib::AttributeID, Ast *prefix, Location loc);

    static Location getNodeLoc(Node node);

    bool has(DomainType *source, SigInstanceDecl *target);
    bool has(const AstRewriter &rewrites,
             DomainType *source, AbstractDomainDecl *target);

    SourceLocation getSourceLoc(Location loc) const {
        return resource.getTextProvider().getSourceLocation(loc);
    }

    DiagnosticStream &report(Location loc, diag::Kind kind) {
        return diagnostic.report(getSourceLoc(loc), kind);
    }
};

} // End comma namespace

#endif

---