// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef ZIRCON_TOOLS_FIDL_INCLUDE_FIDL_ERRORS_H_
#define ZIRCON_TOOLS_FIDL_INCLUDE_FIDL_ERRORS_H_

#include <cassert>
#include <set>
#include <string_view>

#include "source_span.h"

namespace fidl {

// Forward decls
namespace raw {
class Attribute;
class AttributeList;
}  // namespace raw

namespace flat {
struct Constant;
struct IdentifierConstant;
struct LiteralConstant;
struct TypeConstructor;
struct Type;
class TypeTemplate;
class Name;
}  // namespace flat

constexpr int count_format_args(std::string_view s, size_t i = 0) {
  if (i + 1 >= s.size()) {
    return 0;
  }
  int extra = 0;
  if (s[i] == '{' && s[i + 1] == '}') {
    extra = 1;
  }
  return extra + count_format_args(s, i + 1);
}

template <typename... Args>
struct Error {
  std::string_view msg;

  constexpr Error(std::string_view msg) : msg(msg) {
    assert(sizeof...(Args) == count_format_args(msg) &&
           "number of format string parameters '{}' != number of template arguments");
  }
};

// ---------------------------------------------------------------------------
// Library::ConsumeFile: Consume* methods and declaration registration
// ---------------------------------------------------------------------------
constexpr Error<flat::Name> ErrNameCollision(
    "Name collision: {}");
constexpr Error<flat::Name> ErrDeclNameConflictsWithLibraryImport(
    "Declaration name '{}' conflicts with a library import; consider using the "
    "'as' keyword to import the library under a different name.");
constexpr Error ErrFilesDisagreeOnLibraryName(
    "Two files in the library disagree about the name of the library");
constexpr Error<std::vector<std::string_view>> ErrDuplicateLibraryImport(
    "Library {} already imported. Did you require it twice?");
constexpr Error<raw::AttributeList *> ErrAttributesNotAllowedOnLibraryImport(
    "no attributes allowed on library import, found: {}");
constexpr Error<std::vector<std::string_view>> ErrUnknownLibrary(
    "Could not find library named {}. Did you include its sources with --files?");
constexpr Error ErrProtocolComposedMultipleTimes(
    "protocol composed multiple times");
constexpr Error ErrDefaultsOnTablesNotSupported(
    "Defaults on tables are not yet supported.");
constexpr Error ErrNullableTableMember(
    "Table members cannot be nullable");
constexpr Error ErrNullableUnionMember(
    "union members cannot be nullable");

// ---------------------------------------------------------------------------
// Library::Compile: SortDeclarations
// ---------------------------------------------------------------------------
constexpr Error<flat::Name> ErrFailedConstantLookup(
    "Unable to find the constant named: {}");
constexpr Error ErrIncludeCycle(
    "There is an includes-cycle in declarations");

// ---------------------------------------------------------------------------
// Library::Compile: Compilation, Resolution, Validation
// ---------------------------------------------------------------------------
constexpr Error<std::vector<std::string_view>, std::vector<std::string_view>>
ErrUnknownDependentLibrary(
    "Unknown dependent library {} or reference to member of "
    "library {}. Did you require it with `using`?");
constexpr Error<const flat::Type *> ErrInvalidConstantType(
    "invalid constant type {}");
constexpr Error ErrCannotResolveConstantValue(
    "unable to resolve constant value");
constexpr Error ErrOrOperatorOnNonPrimitiveValue(
    "Or operator can only be applied to primitive-kinded values");
constexpr Error ErrUnknownEnumMember(
    "Unknown enum member");
constexpr Error ErrUnknownBitsMember(
    "Unknown bits member");
constexpr Error<flat::IdentifierConstant *> ErrExpectedValueButGotType(
    "{} is a type, but a value was expected");
constexpr Error<flat::Name, flat::Name> ErrMismatchedNameTypeAssignment(
    "mismatched named type assignment: cannot define a constant or default value of type {} "
    "using a value of type {}");
constexpr Error<flat::IdentifierConstant *, const flat::TypeConstructor *, const flat::Type *>
ErrCannotConvertConstantToType(
    "{}, of type {}, cannot be converted to type {}");
constexpr Error<flat::LiteralConstant *, uint64_t, const flat::Type *>
ErrStringConstantExceedsSizeBound(
    "{} (string:{}) exceeds the size bound of type {}");
constexpr Error<flat::LiteralConstant *, const flat::Type *> ErrConstantCannotBeInterpretedAsType(
    "{} cannot be interpreted as type {}");
constexpr Error ErrCouldNotResolveIdentifierToType(
    "could not resolve identifier to a type");
constexpr Error<const flat::Type *> ErrBitsTypeMustBeUnsignedIntegralPrimitive(
    "bits may only be of unsigned integral primitive type, found {}");
constexpr Error<const flat::Type *> ErrEnumTypeMustBeIntegralPrimitive(
    "enums may only be of integral primitive type, found {}");
constexpr Error ErrUnknownAttributeOnInvalidType(
    "[Unknown] attribute can be only be used on flexible or [Transitional] types.");
constexpr Error ErrUnknownAttributeOnMultipleMembers(
    "[Unknown] attribute can be only applied to one member.");
constexpr Error<flat::Name> ErrUnknownType(
    "unknown type {}");
constexpr Error ErrComposingNonProtocol(
    "This declaration is not a protocol");
constexpr Error<SourceSpan> ErrDuplicateMethodName(
    "Multiple methods with the same name in a protocol; last occurrence was at {}");
constexpr Error ErrZeroValueOrdinal(
    "Ordinal value 0 disallowed.");
constexpr Error<SourceSpan, std::string> ErrDuplicateMethodOrdinal(
    "Multiple methods with the same ordinal in a protocol; previous was at {}. "
    "Consider using attribute [Selector=\"{}\"] to change the name used to "
    "calculate the ordinal.");
constexpr Error ErrDuplicateMethodParameterName(
    "Multiple parameters with the same name in a method");
constexpr Error<SourceSpan> ErrDuplicateServiceMemberName(
    "multiple service members with the same name; previous was at {}");
constexpr Error ErrNonProtocolServiceMember(
    "only protocol members are allowed");
constexpr Error ErrNullableServiceMember(
    "service members cannot be nullable");
constexpr Error<SourceSpan> ErrDuplicateStructMemberName(
    "Multiple struct fields with the same name; previous was at {}");
constexpr Error<std::string, const flat::Type *> ErrInvalidStructMemberType(
    "struct field {} has an invalid default type{}");
constexpr Error<SourceSpan> ErrDuplicateTableFieldOrdinal(
    "Multiple table fields with the same ordinal; previous was at {}");
constexpr Error<SourceSpan> ErrDuplicateTableFieldName(
    "Multiple table fields with the same name; previous was at {}");
constexpr Error<uint32_t> ErrNonDenseOrdinalInTable(
    "missing ordinal {} (ordinals must be dense); consider marking it reserved");
constexpr Error<SourceSpan> ErrDuplicateUnionMemberOrdinal(
    "Multiple union fields with the same ordinal; previous was at {}");
constexpr Error<SourceSpan> ErrDuplicateUnionMemberName(
    "Multiple union members with the same name; previous was at {}");
constexpr Error<uint32_t> ErrNonDenseOrdinalInUnion(
    "missing ordinal {} (ordinals must be dense); consider marking it reserved");
constexpr Error ErrCouldNotResolveHandleRights(
    "unable to resolve handle rights");
constexpr Error ErrCouldNotParseSizeBound(
    "unable to parse size bound");
constexpr Error<std::string> ErrCouldNotResolveMember(
    "unable to resolve {} member");
constexpr Error<std::string, std::string, flat::Name> ErrDuplicateMemberName(
    "name of member {} conflicts with previously declared member in the {} {}");
constexpr Error<std::string, std::string, std::string, flat::Name> ErrDuplicateMemberValue(
    "value of member {} conflicts with previously declared member {} in the {} {}");

// ---------------------------------------------------------------------------
// Attribute Validation: Placement, Values, Constraints
// ---------------------------------------------------------------------------
constexpr Error<raw::Attribute> ErrInvalidAttributePlacement(
    "placement of attribute '{}' disallowed here");
constexpr Error<raw::Attribute, std::string, std::set<std::string>> ErrInvalidAttributeValue(
    "attribute '{}' has invalid value '{}', should be one of '{}'");
constexpr Error<raw::Attribute, std::string> ErrAttributeConstraintNotSatisfied(
    "declaration did not satisfy constraint of attribute '{}' with value '{}'");
constexpr Error<flat::Name> ErrUnionCannotBeSimple(
    "union '{}' is not allowed to be simple");
constexpr Error<std::string> ErrStructMemberMustBeSimple(
    "member '{}' is not simple");
constexpr Error<uint32_t, uint32_t> ErrTooManyBytes(
    "too large: only {} bytes allowed, but {} bytes found");
constexpr Error<uint32_t, uint32_t> ErrTooManyHandles(
    "too many handles: only {} allowed, but {} found");
constexpr Error ErrInvalidErrorType(
    "invalid error type: must be int32, uint32 or an enum therof");
constexpr Error<std::string, std::set<std::string>> ErrInvalidTransportType(
    "invalid transport type: got {} expected one of {}");
constexpr Error ErrBoundIsTooBig(
    "bound is too big");
constexpr Error<std::string> ErrUnableToParseBound(
    "unable to parse bound '{}'");
constexpr Error<std::string, std::string> WarnAttributeTypo(
    "suspect attribute with name '{}'; did you mean '{}'?");

// ---------------------------------------------------------------------------
// Type Templates
// ---------------------------------------------------------------------------
constexpr Error<flat::Name> ErrUnknownTypeTemplate(
    "unknown type {}");
constexpr Error<const flat::TypeTemplate *> ErrMustBeAProtocol(
    "{} must be a protocol");
constexpr Error<const flat::TypeTemplate *> ErrCannotUseServicesInOtherDeclarations(
    "{} cannot use services in other declarations");
constexpr Error<const flat::TypeTemplate *> ErrCannotParametrizeTwice(
    "{} cannot parametrize twice");
constexpr Error<const flat::TypeTemplate *> ErrCannotBoundTwice(
    "{} cannot bound twice");
constexpr Error<const flat::TypeTemplate *> ErrCannotIndicateNullabilityTwice(
    "{} cannot indicate nullability twice");
constexpr Error<const flat::TypeTemplate *> ErrMustBeParameterized(
    "{} must be parametrized");
constexpr Error<const flat::TypeTemplate *> ErrMustHaveSize(
    "{} must have size");
constexpr Error<const flat::TypeTemplate *> ErrMustHaveNonZeroSize(
    "{} must have non-zero size");
constexpr Error<const flat::TypeTemplate *> ErrCannotBeParameterized(
    "{} cannot be parametrized");
constexpr Error<const flat::TypeTemplate *> ErrCannotHaveSize(
    "{} cannot have size");
constexpr Error<const flat::TypeTemplate *> ErrCannotBeNullable(
    "{} cannot be nullable");

constexpr Error<std::vector<std::string_view>, std::vector<std::string_view>,
                std::vector<std::string_view>> ErrUnusedImport(
    "Library {} imports {} but does not use it. Either use {}, or remove import.");

}  // namespace fidl

#endif  // ZIRCON_TOOLS_FIDL_INCLUDE_FIDL_ERRORS_H_