// Copyright 2020 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef SRC_TINT_RESOLVER_VALIDATOR_H_
#define SRC_TINT_RESOLVER_VALIDATOR_H_

#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

#include "src/tint/ast/pipeline_stage.h"
#include "src/tint/program_builder.h"
#include "src/tint/resolver/sem_helper.h"
#include "src/tint/source.h"

// Forward declarations
namespace tint::ast {
class IndexAccessorExpression;
class BinaryExpression;
class BitcastExpression;
class CallExpression;
class CallStatement;
class CaseStatement;
class ForLoopStatement;
class Function;
class IdentifierExpression;
class LoopStatement;
class MemberAccessorExpression;
class ReturnStatement;
class SwitchStatement;
class UnaryOpExpression;
class Variable;
}  // namespace tint::ast
namespace tint::sem {
class Array;
class Atomic;
class BlockStatement;
class Builtin;
class CaseStatement;
class ElseStatement;
class ForLoopStatement;
class IfStatement;
class LoopStatement;
class Statement;
class SwitchStatement;
class TypeConstructor;
}  // namespace tint::sem

namespace tint::resolver {

/// Validation logic for various ast nodes. The validations in general should
/// be shallow and depend on the resolver to call on children. The validations
/// also assume that sem changes have already been made. The validation checks
/// should not alter the AST or SEM trees.
class Validator {
 public:
  /// The valid type storage layouts typedef
  using ValidTypeStorageLayouts =
      std::set<std::pair<const sem::Type*, ast::StorageClass>>;

  /// Constructor
  /// @param builder the program builder
  /// @param helper the SEM helper to validate with
  Validator(ProgramBuilder* builder, SemHelper& helper);
  ~Validator();

  /// Adds the given error message to the diagnostics
  /// @param msg the error message
  /// @param source the error source
  void AddError(const std::string& msg, const Source& source) const;

  /// Adds the given warning message to the diagnostics
  /// @param msg the warning message
  /// @param source the warning source
  void AddWarning(const std::string& msg, const Source& source) const;

  /// Adds the given note message to the diagnostics
  /// @param msg the note message
  /// @param source the note source
  void AddNote(const std::string& msg, const Source& source) const;

  /// @param type the given type
  /// @returns true if the given type is a plain type
  bool IsPlain(const sem::Type* type) const;

  /// @param type the given type
  /// @returns true if the given type is a fixed-footprint type
  bool IsFixedFootprint(const sem::Type* type) const;

  /// @param type the given type
  /// @returns true if the given type is storable
  bool IsStorable(const sem::Type* type) const;

  /// @param type the given type
  /// @returns true if the given type is host-shareable
  bool IsHostShareable(const sem::Type* type) const;

  /// Validates pipeline stages
  /// @param entry_points the entry points to the module
  /// @returns true on success, false otherwise.
  bool PipelineStages(const std::vector<sem::Function*>& entry_points) const;

  /// Validates aliases
  /// @param alias the alias to validate
  /// @returns true on success, false otherwise.
  bool Alias(const ast::Alias* alias) const;

  /// Validates the array
  /// @param arr the array to validate
  /// @param source the source of the array
  /// @returns true on success, false otherwise.
  bool Array(const sem::Array* arr, const Source& source) const;

  /// Validates an array stride attribute
  /// @param attr the stride attribute to validate
  /// @param el_size the element size
  /// @param el_align the element alignment
  /// @param source the source of the attribute
  /// @returns true on success, false otherwise
  bool ArrayStrideAttribute(const ast::StrideAttribute* attr,
                            uint32_t el_size,
                            uint32_t el_align,
                            const Source& source) const;

  /// Validates an atomic
  /// @param a the atomic ast node to validate
  /// @param s the atomic sem node
  /// @returns true on success, false otherwise.
  bool Atomic(const ast::Atomic* a, const sem::Atomic* s) const;

  /// Validates an atoic variable
  /// @param var the variable to validate
  /// @param atomic_composite_info store atomic information
  /// @returns true on success, false otherwise.
  bool AtomicVariable(const sem::Variable* var,
                      std::unordered_map<const sem::Type*, const Source&>
                          atomic_composite_info) const;

  /// Validates an assignment
  /// @param a the assignment statement
  /// @param rhs_ty the type of the right hand side
  /// @returns true on success, false otherwise.
  bool Assignment(const ast::Statement* a, const sem::Type* rhs_ty) const;

  /// Validates a bitcase
  /// @param cast the bitcast expression
  /// @param to the destination type
  /// @returns true on success, false otherwise
  bool Bitcast(const ast::BitcastExpression* cast, const sem::Type* to) const;

  /// Validates a break statement
  /// @param stmt the break statement to validate
  /// @param current_statement the current statement being resolved
  /// @returns true on success, false otherwise.
  bool BreakStatement(const sem::Statement* stmt,
                      sem::Statement* current_statement) const;

  /// Validates a builtin attribute
  /// @param attr the attribute to validate
  /// @param storage_type the attribute storage type
  /// @param stage the current pipeline stage
  /// @param is_input true if this is an input attribute
  /// @returns true on success, false otherwise.
  bool BuiltinAttribute(const ast::BuiltinAttribute* attr,
                        const sem::Type* storage_type,
                        ast::PipelineStage stage,
                        const bool is_input) const;

  /// Validates a continue statement
  /// @param stmt the continue statement to validate
  /// @param current_statement the current statement being resolved
  /// @returns true on success, false otherwise
  bool ContinueStatement(const sem::Statement* stmt,
                         sem::Statement* current_statement) const;

  /// Validates a discard statement
  /// @param stmt the statement to validate
  /// @param current_statement the current statement being resolved
  /// @returns true on success, false otherwise
  bool DiscardStatement(const sem::Statement* stmt,
                        sem::Statement* current_statement) const;

  /// Validates an else statement
  /// @param stmt the else statement to validate
  /// @returns true on success, false otherwise
  bool ElseStatement(const sem::ElseStatement* stmt) const;

  /// Validates an entry point
  /// @param func the entry point function to validate
  /// @param stage the pipeline stage for the entry point
  /// @returns true on success, false otherwise
  bool EntryPoint(const sem::Function* func, ast::PipelineStage stage) const;

  /// Validates a for loop
  /// @param stmt the for loop statement to validate
  /// @returns true on success, false otherwise
  bool ForLoopStatement(const sem::ForLoopStatement* stmt) const;

  /// Validates a fallthrough statement
  /// @param stmt the fallthrough to validate
  /// @returns true on success, false otherwise
  bool FallthroughStatement(const sem::Statement* stmt) const;

  /// Validates a function
  /// @param func the function to validate
  /// @param stage the current pipeline stage
  /// @returns true on success, false otherwise.
  bool Function(const sem::Function* func, ast::PipelineStage stage) const;

  /// Validates a function call
  /// @param call the function call to validate
  /// @param current_statement the current statement being resolved
  /// @returns true on success, false otherwise
  bool FunctionCall(const sem::Call* call,
                    sem::Statement* current_statement) const;

  /// Validates a global variable
  /// @param var the global variable to validate
  /// @param constant_ids the set of constant ids in the module
  /// @param atomic_composite_info atomic composite info in the module
  /// @returns true on success, false otherwise
  bool GlobalVariable(
      const sem::Variable* var,
      std::unordered_map<uint32_t, const sem::Variable*> constant_ids,
      std::unordered_map<const sem::Type*, const Source&> atomic_composite_info)
      const;

  /// Validates an if statement
  /// @param stmt the statement to validate
  /// @returns true on success, false otherwise
  bool IfStatement(const sem::IfStatement* stmt) const;

  /// Validates an increment or decrement statement
  /// @param stmt the statement to validate
  /// @returns true on success, false otherwise
  bool IncrementDecrementStatement(
      const ast::IncrementDecrementStatement* stmt) const;

  /// Validates an interpolate attribute
  /// @param attr the interpolation attribute to validate
  /// @param storage_type the storage type of the attached variable
  /// @returns true on succes, false otherwise
  bool InterpolateAttribute(const ast::InterpolateAttribute* attr,
                            const sem::Type* storage_type) const;

  /// Validates a builtin call
  /// @param call the builtin call to validate
  /// @returns true on success, false otherwise.
  bool BuiltinCall(const sem::Call* call) const;

  /// Validates a location attribute
  /// @param location the location attribute to validate
  /// @param type the variable type
  /// @param locations the set of locations in the module
  /// @param stage the current pipeline stage
  /// @param source the source of the attribute
  /// @param is_input true if this is an input variable
  /// @returns true on success, false otherwise.
  bool LocationAttribute(const ast::LocationAttribute* location,
                         const sem::Type* type,
                         std::unordered_set<uint32_t>& locations,
                         ast::PipelineStage stage,
                         const Source& source,
                         const bool is_input = false) const;

  /// Validates a loop statement
  /// @param stmt the loop statement
  /// @returns true on success, false otherwise.
  bool LoopStatement(const sem::LoopStatement* stmt) const;

  /// Validates a matrix
  /// @param ty the matrix to validate
  /// @param source the source of the matrix
  /// @returns true on success, false otherwise
  bool Matrix(const sem::Matrix* ty, const Source& source) const;

  /// Validates a function parameter
  /// @param func the function the variable is for
  /// @param var the variable to validate
  /// @returns true on success, false otherwise
  bool FunctionParameter(const ast::Function* func,
                         const sem::Variable* var) const;

  /// Validates a return
  /// @param ret the return statement to validate
  /// @param func_type the return type of the curreunt function
  /// @param ret_type the return type
  /// @param current_statement the current statement being resolved
  /// @returns true on success, false otherwise
  bool Return(const ast::ReturnStatement* ret,
              const sem::Type* func_type,
              const sem::Type* ret_type,
              sem::Statement* current_statement) const;

  /// Validates a list of statements
  /// @param stmts the statements to validate
  /// @returns true on success, false otherwise
  bool Statements(const ast::StatementList& stmts) const;

  /// Validates a storage texture
  /// @param t the texture to validate
  /// @returns true on success, false otherwise
  bool StorageTexture(const ast::StorageTexture* t) const;

  /// Validates a structure
  /// @param str the structure to validate
  /// @param stage the current pipeline stage
  /// @returns true on success, false otherwise.
  bool Structure(const sem::Struct* str, ast::PipelineStage stage) const;

  /// Validates a structure constructor or cast
  /// @param ctor the call expression to validate
  /// @param struct_type the type of the structure
  /// @returns true on success, false otherwise
  bool StructureConstructorOrCast(const ast::CallExpression* ctor,
                                  const sem::Struct* struct_type) const;

  /// Validates a switch statement
  /// @param s the switch to validate
  /// @returns true on success, false otherwise
  bool SwitchStatement(const ast::SwitchStatement* s);

  /// Validates a variable
  /// @param var the variable to validate
  /// @returns true on success, false otherwise.
  bool Variable(const sem::Variable* var) const;

  /// Validates a variable constructor or cast
  /// @param var the variable to validate
  /// @param storage_class the storage class of the variable
  /// @param storage_type the type of the storage
  /// @param rhs_type the right hand side of the expression
  /// @returns true on succes, false otherwise
  bool VariableConstructorOrCast(const ast::Variable* var,
                                 ast::StorageClass storage_class,
                                 const sem::Type* storage_type,
                                 const sem::Type* rhs_type) const;

  /// Validates a vector
  /// @param ty the vector to validate
  /// @param source the source of the vector
  /// @returns true on success, false otherwise
  bool Vector(const sem::Vector* ty, const Source& source) const;

  /// Validates a vector constructor or cast
  /// @param ctor the call expression to validate
  /// @param vec_type the vector type
  /// @returns true on success, false otherwise
  bool VectorConstructorOrCast(const ast::CallExpression* ctor,
                               const sem::Vector* vec_type) const;

  /// Validates a matrix constructor or cast
  /// @param ctor the call expression to validate
  /// @param matrix_type the type of the matrix
  /// @returns true on success, false otherwise
  bool MatrixConstructorOrCast(const ast::CallExpression* ctor,
                               const sem::Matrix* matrix_type) const;

  /// Validates a scalar constructor or cast
  /// @param ctor the call expression to validate
  /// @param type the type of the scalar
  /// @returns true on success, false otherwise.
  bool ScalarConstructorOrCast(const ast::CallExpression* ctor,
                               const sem::Type* type) const;

  /// Validates an array constructor or cast
  /// @param ctor the call expresion to validate
  /// @param arr_type the type of the array
  /// @returns true on success, false otherwise
  bool ArrayConstructorOrCast(const ast::CallExpression* ctor,
                              const sem::Array* arr_type) const;

  /// Validates a texture builtin function
  /// @param call the builtin call to validate
  /// @returns true on success, false otherwise
  bool TextureBuiltinFunction(const sem::Call* call) const;

  /// Validates there are no duplicate attributes
  /// @param attributes the list of attributes to validate
  /// @returns true on success, false otherwise.
  bool NoDuplicateAttributes(const ast::AttributeList& attributes) const;

  /// Validates a storage class layout
  /// @param type the type to validate
  /// @param sc the storage class
  /// @param source the source of the type
  /// @param layouts previously validated storage layouts
  /// @returns true on success, false otherwise
  bool StorageClassLayout(const sem::Type* type,
                          ast::StorageClass sc,
                          Source source,
                          ValidTypeStorageLayouts& layouts) const;

  /// Validates a storage class layout
  /// @param var the variable to validate
  /// @param layouts previously validated storage layouts
  /// @returns true on success, false otherwise.
  bool StorageClassLayout(const sem::Variable* var,
                          ValidTypeStorageLayouts& layouts) const;

  /// @returns true if the attribute list contains a
  /// ast::DisableValidationAttribute with the validation mode equal to
  /// `validation`
  /// @param attributes the attribute list to check
  /// @param validation the validation mode to check
  bool IsValidationDisabled(const ast::AttributeList& attributes,
                            ast::DisabledValidation validation) const;

  /// @returns true if the attribute list does not contains a
  /// ast::DisableValidationAttribute with the validation mode equal to
  /// `validation`
  /// @param attributes the attribute list to check
  /// @param validation the validation mode to check
  bool IsValidationEnabled(const ast::AttributeList& attributes,
                           ast::DisabledValidation validation) const;

 private:
  /// Searches the current statement and up through parents of the current
  /// statement looking for a loop or for-loop continuing statement.
  /// @returns the closest continuing statement to the current statement that
  /// (transitively) owns the current statement.
  /// @param stop_at_loop if true then the function will return nullptr if a
  /// loop or for-loop was found before the continuing.
  /// @param current_statement the current statement being resolved
  const ast::Statement* ClosestContinuing(
      bool stop_at_loop,
      sem::Statement* current_statement) const;

  /// Returns a human-readable string representation of the vector type name
  /// with the given parameters.
  /// @param size the vector dimension
  /// @param element_type scalar vector sub-element type
  /// @return pretty string representation
  std::string VectorPretty(uint32_t size, const sem::Type* element_type) const;

  SymbolTable& symbols_;
  diag::List& diagnostics_;
  SemHelper& sem_;
};

}  // namespace tint::resolver

#endif  // SRC_TINT_RESOLVER_VALIDATOR_H_