llvm/clang/lib/Sema/SemaSwift.cpp

//===------ SemaSwift.cpp ------ Swift language-specific routines ---------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
//  This file implements semantic analysis functions specific to Swift.
//
//===----------------------------------------------------------------------===//

#include "clang/Sema/SemaSwift.h"
#include "clang/AST/DeclBase.h"
#include "clang/Basic/AttributeCommonInfo.h"
#include "clang/Basic/DiagnosticSema.h"
#include "clang/Basic/Specifiers.h"
#include "clang/Sema/Attr.h"
#include "clang/Sema/ParsedAttr.h"
#include "clang/Sema/Sema.h"
#include "clang/Sema/SemaObjC.h"

namespace clang {
SemaSwift::SemaSwift(Sema &S) : … { … }

SwiftNameAttr *SemaSwift::mergeNameAttr(Decl *D, const SwiftNameAttr &SNA,
                                        StringRef Name) { … }

/// Pointer-like types in the default address space.
static bool isValidSwiftContextType(QualType Ty) { … }

/// Pointers and references in the default address space.
static bool isValidSwiftIndirectResultType(QualType Ty) { … }

/// Pointers and references to pointers in the default address space.
static bool isValidSwiftErrorResultType(QualType Ty) { … }

void SemaSwift::handleAttrAttr(Decl *D, const ParsedAttr &AL) { … }

void SemaSwift::handleBridge(Decl *D, const ParsedAttr &AL) { … }

static bool isErrorParameter(Sema &S, QualType QT) { … }

void SemaSwift::handleError(Decl *D, const ParsedAttr &AL) { … }

static void checkSwiftAsyncErrorBlock(Sema &S, Decl *D,
                                      const SwiftAsyncErrorAttr *ErrorAttr,
                                      const SwiftAsyncAttr *AsyncAttr) { … }

void SemaSwift::handleAsyncError(Decl *D, const ParsedAttr &AL) { … }

// For a function, this will validate a compound Swift name, e.g.
// <code>init(foo:bar:baz:)</code> or <code>controllerForName(_:)</code>, and
// the function will output the number of parameter names, and whether this is a
// single-arg initializer.
//
// For a type, enum constant, property, or variable declaration, this will
// validate either a simple identifier, or a qualified
// <code>context.identifier</code> name.
static bool validateSwiftFunctionName(Sema &S, const ParsedAttr &AL,
                                      SourceLocation Loc, StringRef Name,
                                      unsigned &SwiftParamCount,
                                      bool &IsSingleParamInit) { … }

bool SemaSwift::DiagnoseName(Decl *D, StringRef Name, SourceLocation Loc,
                             const ParsedAttr &AL, bool IsAsync) { … }

void SemaSwift::handleName(Decl *D, const ParsedAttr &AL) { … }

void SemaSwift::handleAsyncName(Decl *D, const ParsedAttr &AL) { … }

void SemaSwift::handleNewType(Decl *D, const ParsedAttr &AL) { … }

void SemaSwift::handleAsyncAttr(Decl *D, const ParsedAttr &AL) { … }

void SemaSwift::AddParameterABIAttr(Decl *D, const AttributeCommonInfo &CI,
                                    ParameterABI abi) { … }

} // namespace clang