mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
9e22b70cff
IRGenDebugInfo assumes that all argument names within the same scope are unique as it uses them as a key in a hash table. rdar://102367872
123 lines
4.2 KiB
C++
123 lines
4.2 KiB
C++
//===--- Parameter.cpp - Functions & closures parameters ------------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines the Parameter class, the ParameterList class and support
|
|
// logic.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "swift/AST/ParameterList.h"
|
|
#include "swift/AST/ASTContext.h"
|
|
#include "swift/AST/Expr.h"
|
|
#include "swift/AST/Types.h"
|
|
using namespace swift;
|
|
|
|
/// TODO: unique and reuse the () parameter list in ASTContext, it is common to
|
|
/// many methods. Other parameter lists cannot be uniqued because the decls
|
|
/// within them are always different anyway (they have different DeclContext's).
|
|
ParameterList *
|
|
ParameterList::create(const ASTContext &C, SourceLoc LParenLoc,
|
|
ArrayRef<ParamDecl*> params, SourceLoc RParenLoc) {
|
|
assert(LParenLoc.isValid() == RParenLoc.isValid() &&
|
|
"Either both paren locs are valid or neither are");
|
|
|
|
auto byteSize = totalSizeToAlloc<ParamDecl *>(params.size());
|
|
auto rawMem = C.Allocate(byteSize, alignof(ParameterList));
|
|
|
|
// Placement initialize the ParameterList and the Parameter's.
|
|
auto PL = ::new (rawMem) ParameterList(LParenLoc, params.size(), RParenLoc);
|
|
|
|
std::uninitialized_copy(params.begin(), params.end(), PL->getArray().begin());
|
|
|
|
return PL;
|
|
}
|
|
|
|
/// Change the DeclContext of any contained parameters to the specified
|
|
/// DeclContext.
|
|
void ParameterList::setDeclContextOfParamDecls(DeclContext *DC) {
|
|
for (auto P : *this)
|
|
P->setDeclContext(DC);
|
|
}
|
|
|
|
/// Make a duplicate copy of this parameter list. This allocates copies of
|
|
/// the ParamDecls, so they can be reparented into a new DeclContext.
|
|
ParameterList *ParameterList::clone(const ASTContext &C,
|
|
OptionSet<CloneFlags> options) const {
|
|
// TODO(distributed): copy types thanks to flag in options
|
|
// If this list is empty, don't actually bother with a copy.
|
|
if (size() == 0)
|
|
return const_cast<ParameterList*>(this);
|
|
|
|
SmallVector<ParamDecl*, 8> params(begin(), end());
|
|
|
|
// Remap the ParamDecls inside of the ParameterList.
|
|
unsigned i = 0;
|
|
for (auto &decl : params) {
|
|
auto defaultArgKind = decl->getDefaultArgumentKind();
|
|
|
|
decl = ParamDecl::cloneWithoutType(C, decl);
|
|
if (options & Implicit)
|
|
decl->setImplicit();
|
|
|
|
// If the argument isn't named, give the parameter a name so that
|
|
// silgen will produce a value for it.
|
|
if (decl->getName().empty() && (options & NamedArguments)) {
|
|
llvm::SmallString<16> s;
|
|
{ llvm::raw_svector_ostream(s) << "__argument" << ++i; }
|
|
decl->setName(C.getIdentifier(s));
|
|
}
|
|
|
|
// If we're inheriting a default argument, mark it as such.
|
|
// FIXME: Figure out how to clone default arguments as well.
|
|
if (options & Inherited) {
|
|
switch (defaultArgKind) {
|
|
case DefaultArgumentKind::Normal:
|
|
case DefaultArgumentKind::StoredProperty:
|
|
decl->setDefaultArgumentKind(DefaultArgumentKind::Inherited);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
} else {
|
|
decl->setDefaultArgumentKind(DefaultArgumentKind::None);
|
|
}
|
|
}
|
|
|
|
return create(C, params);
|
|
}
|
|
|
|
void ParameterList::getParams(
|
|
SmallVectorImpl<AnyFunctionType::Param> ¶ms) const {
|
|
for (auto P : *this)
|
|
params.push_back(P->toFunctionParam());
|
|
}
|
|
|
|
|
|
/// Return the full source range of this parameter list.
|
|
SourceRange ParameterList::getSourceRange() const {
|
|
// If we have locations for the parens, then they define our range.
|
|
if (LParenLoc.isValid())
|
|
return { LParenLoc, RParenLoc };
|
|
|
|
// Otherwise, try the first and last parameter.
|
|
if (size() != 0) {
|
|
auto Start = get(0)->getStartLoc();
|
|
auto End = getArray().back()->getEndLoc();
|
|
if (Start.isValid() && End.isValid())
|
|
return { Start, End };
|
|
}
|
|
|
|
return SourceRange();
|
|
}
|
|
|