mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
65b400e30d
and is just an unmanaged pointer. Also, introduce a basic swift.string type. This is progress towards rdar://10923403 and strings. Review welcome. Swift SVN r1349
271 lines
10 KiB
C++
271 lines
10 KiB
C++
//===--- ASTContext.cpp - ASTContext Implementation -----------------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See http://swift.org/LICENSE.txt for license information
|
|
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the ASTContext class.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "swift/AST/ASTContext.h"
|
|
#include "swift/AST/AST.h"
|
|
#include "swift/AST/DiagnosticEngine.h"
|
|
#include "llvm/Support/Allocator.h"
|
|
#include "llvm/Support/SourceMgr.h"
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/StringMap.h"
|
|
using namespace swift;
|
|
|
|
struct ASTContext::Implementation {
|
|
Implementation();
|
|
~Implementation();
|
|
|
|
llvm::BumpPtrAllocator Allocator; // used in later initializations
|
|
llvm::StringMap<char, llvm::BumpPtrAllocator&> IdentifierTable;
|
|
llvm::FoldingSet<TupleType> TupleTypes;
|
|
llvm::DenseMap<TypeAliasDecl*, MetaTypeType*> MetaTypeTypes;
|
|
llvm::DenseMap<Module*, ModuleType*> ModuleTypes;
|
|
llvm::DenseMap<std::pair<Type,std::pair<Type,char>>,
|
|
FunctionType*> FunctionTypes;
|
|
llvm::DenseMap<std::pair<Type, uint64_t>, ArrayType*> ArrayTypes;
|
|
llvm::DenseMap<unsigned, BuiltinIntegerType*> IntegerTypes;
|
|
llvm::DenseMap<Type, ParenType*> ParenTypes;
|
|
llvm::DenseMap<std::pair<Type, LValueType::Qual::opaque_type>, LValueType*>
|
|
LValueTypes;
|
|
};
|
|
ASTContext::Implementation::Implementation()
|
|
: IdentifierTable(Allocator) {}
|
|
ASTContext::Implementation::~Implementation() {}
|
|
|
|
ASTContext::ASTContext(llvm::SourceMgr &sourcemgr, DiagnosticEngine &Diags)
|
|
: Impl(*new Implementation()),
|
|
SourceMgr(sourcemgr),
|
|
Diags(Diags),
|
|
TheBuiltinModule(new (*this) BuiltinModule(getIdentifier("Builtin"),*this)),
|
|
TheErrorType(new (*this) ErrorType(*this)),
|
|
TheEmptyTupleType(TupleType::get(ArrayRef<TupleTypeElt>(), *this)),
|
|
TheObjectPointerType(new (*this) BuiltinObjectPointerType(*this)),
|
|
TheRawPointerType(new (*this) BuiltinRawPointerType(*this)),
|
|
TheUnstructuredDependentType(new (*this) UnstructuredDependentType(*this)),
|
|
TheIEEE32Type(new (*this) BuiltinFloatType(BuiltinFloatType::IEEE32,*this)),
|
|
TheIEEE64Type(new (*this) BuiltinFloatType(BuiltinFloatType::IEEE64,*this)),
|
|
TheIEEE16Type(new (*this) BuiltinFloatType(BuiltinFloatType::IEEE16,*this)),
|
|
TheIEEE80Type(new (*this) BuiltinFloatType(BuiltinFloatType::IEEE80,*this)),
|
|
TheIEEE128Type(new (*this) BuiltinFloatType(BuiltinFloatType::IEEE128,
|
|
*this)),
|
|
ThePPC128Type(new (*this) BuiltinFloatType(BuiltinFloatType::PPC128,*this)){
|
|
}
|
|
|
|
ASTContext::~ASTContext() {
|
|
delete &Impl;
|
|
}
|
|
|
|
void *ASTContext::Allocate(unsigned long Bytes, unsigned Alignment) {
|
|
return Impl.Allocator.Allocate(Bytes, Alignment);
|
|
}
|
|
|
|
/// getIdentifier - Return the uniqued and AST-Context-owned version of the
|
|
/// specified string.
|
|
Identifier ASTContext::getIdentifier(StringRef Str) {
|
|
// Make sure null pointers stay null.
|
|
if (Str.empty()) return Identifier(0);
|
|
|
|
return Identifier(Impl.IdentifierTable.GetOrCreateValue(Str).getKeyData());
|
|
}
|
|
|
|
bool ASTContext::hadError() const {
|
|
return Diags.hadAnyError();
|
|
}
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Type manipulation routines.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Simple accessors.
|
|
Type ErrorType::get(ASTContext &C) { return C.TheErrorType; }
|
|
Type UnstructuredDependentType::get(ASTContext &C) {
|
|
return C.TheUnstructuredDependentType;
|
|
}
|
|
|
|
|
|
BuiltinIntegerType *BuiltinIntegerType::get(unsigned BitWidth, ASTContext &C) {
|
|
BuiltinIntegerType *&Result = C.Impl.IntegerTypes[BitWidth];
|
|
if (Result == 0)
|
|
Result = new (C) BuiltinIntegerType(BitWidth, C);
|
|
return Result;
|
|
}
|
|
|
|
ParenType *ParenType::get(ASTContext &C, Type underlying) {
|
|
ParenType *&Result = C.Impl.ParenTypes[underlying];
|
|
if (Result == 0)
|
|
Result = new (C) ParenType(underlying);
|
|
return Result;
|
|
}
|
|
|
|
Type TupleType::getEmpty(ASTContext &C) { return C.TheEmptyTupleType; }
|
|
|
|
void TupleType::Profile(llvm::FoldingSetNodeID &ID,
|
|
ArrayRef<TupleTypeElt> Fields) {
|
|
ID.AddInteger(Fields.size());
|
|
for (const TupleTypeElt &Elt : Fields) {
|
|
ID.AddPointer(Elt.getType().getPointer());
|
|
ID.AddPointer(Elt.getName().get());
|
|
ID.AddPointer(Elt.getInit());
|
|
}
|
|
}
|
|
|
|
/// getTupleType - Return the uniqued tuple type with the specified elements.
|
|
TupleType *TupleType::get(ArrayRef<TupleTypeElt> Fields, ASTContext &C) {
|
|
// Check to see if we've already seen this tuple before.
|
|
llvm::FoldingSetNodeID ID;
|
|
TupleType::Profile(ID, Fields);
|
|
|
|
// FIXME: This is pointless for types with named fields. The ValueDecl fields
|
|
// themselves are not unique'd so they all get their own addresses, which
|
|
// means that we'll never get a hit here. This should unique all-type tuples
|
|
// though. Likewise with default values.
|
|
void *InsertPos = 0;
|
|
if (TupleType *TT = C.Impl.TupleTypes.FindNodeOrInsertPos(ID, InsertPos))
|
|
return TT;
|
|
|
|
// Okay, we didn't find one. Make a copy of the fields list into ASTContext
|
|
// owned memory.
|
|
TupleTypeElt *FieldsCopy =
|
|
C.AllocateCopy<TupleTypeElt>(Fields.begin(), Fields.end());
|
|
|
|
bool IsCanonical = true; // All canonical elts means this is canonical.
|
|
for (const TupleTypeElt &Elt : Fields) {
|
|
if (Elt.getType().isNull() || !Elt.getType()->isCanonical()) {
|
|
IsCanonical = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
Fields = ArrayRef<TupleTypeElt>(FieldsCopy, Fields.size());
|
|
|
|
TupleType *New = new (C) TupleType(Fields, IsCanonical ? &C : 0);
|
|
C.Impl.TupleTypes.InsertNode(New, InsertPos);
|
|
|
|
return New;
|
|
}
|
|
|
|
/// getNewOneOfType - Return a new instance of oneof type. These are never
|
|
/// uniqued because the loc is generally different.
|
|
OneOfType *OneOfType::getNew(SourceLoc OneOfLoc,
|
|
ArrayRef<OneOfElementDecl*> InElts,
|
|
TypeAliasDecl *TheDecl) {
|
|
ASTContext &C = TheDecl->getASTContext();
|
|
|
|
return new (C) OneOfType(OneOfLoc, C.AllocateCopy(InElts), TheDecl);
|
|
}
|
|
|
|
// oneof types are always canonical.
|
|
OneOfType::OneOfType(SourceLoc OneOfLoc, ArrayRef<OneOfElementDecl*> Elts,
|
|
TypeAliasDecl *TheDecl)
|
|
: TypeBase(TypeKind::OneOf, &TheDecl->getASTContext(),
|
|
/*Dependent=*/false),
|
|
DeclContext(DeclContextKind::OneOfType, TheDecl->getDeclContext()),
|
|
OneOfLoc(OneOfLoc), Elements(Elts), TheDecl(TheDecl) {
|
|
}
|
|
|
|
IdentifierType *IdentifierType::getNew(ASTContext &C,
|
|
MutableArrayRef<Component> Components) {
|
|
Components = C.AllocateCopy(Components);
|
|
return new (C) IdentifierType(Components);
|
|
}
|
|
|
|
|
|
MetaTypeType *MetaTypeType::get(TypeAliasDecl *Type) {
|
|
ASTContext &C = Type->getASTContext();
|
|
|
|
MetaTypeType *&Entry = C.Impl.MetaTypeTypes[Type];
|
|
if (Entry) return Entry;
|
|
|
|
return Entry = new (C) MetaTypeType(Type, C);
|
|
}
|
|
|
|
ModuleType *ModuleType::get(Module *M) {
|
|
ASTContext &C = M->getASTContext();
|
|
|
|
ModuleType *&Entry = C.Impl.ModuleTypes[M];
|
|
if (Entry) return Entry;
|
|
|
|
return Entry = new (C) ModuleType(M, C);
|
|
}
|
|
|
|
/// FunctionType::get - Return a uniqued function type with the specified
|
|
/// input and result.
|
|
FunctionType *FunctionType::get(Type Input, Type Result, bool isAutoClosure,
|
|
ASTContext &C) {
|
|
FunctionType *&Entry =
|
|
C.Impl.FunctionTypes[std::make_pair(Input,
|
|
std::make_pair(Result,
|
|
(char)isAutoClosure))];
|
|
if (Entry) return Entry;
|
|
|
|
return Entry = new (C) FunctionType(Input, Result, isAutoClosure);
|
|
}
|
|
|
|
// If the input and result types are canonical, then so is the result.
|
|
FunctionType::FunctionType(Type input, Type result, bool isAutoClosure)
|
|
: TypeBase(TypeKind::Function,
|
|
(input->isCanonical() && result->isCanonical()) ?
|
|
&input->getASTContext() : 0,
|
|
(input->isDependentType() || result->isDependentType())),
|
|
Input(input), Result(result), AutoClosure(isAutoClosure) { }
|
|
|
|
|
|
/// getArrayType - Return a uniqued array type with the specified base type
|
|
/// and the specified size. Size=0 indicates an unspecified size array.
|
|
ArrayType *ArrayType::get(Type BaseType, uint64_t Size, ASTContext &C) {
|
|
ArrayType *&Entry = C.Impl.ArrayTypes[std::make_pair(BaseType, Size)];
|
|
if (Entry) return Entry;
|
|
|
|
return Entry = new (C) ArrayType(BaseType, Size);
|
|
}
|
|
|
|
ArrayType::ArrayType(Type base, uint64_t size)
|
|
: TypeBase(TypeKind::Array,
|
|
base->isCanonical() ? &base->getASTContext() : 0,
|
|
base->isDependentType()),
|
|
Base(base), Size(size) {}
|
|
|
|
|
|
|
|
/// getNew - Return a new instance of a protocol type. These are never
|
|
/// uniqued since each syntactic instance of them is semantically considered
|
|
/// to be a different type.
|
|
ProtocolType *ProtocolType::getNew(SourceLoc ProtocolLoc,
|
|
ArrayRef<ValueDecl*> Elts,
|
|
TypeAliasDecl *TheDecl) {
|
|
ASTContext &C = TheDecl->getASTContext();
|
|
return new (C) ProtocolType(ProtocolLoc, C.AllocateCopy(Elts), TheDecl);
|
|
}
|
|
|
|
ProtocolType::ProtocolType(SourceLoc ProtocolLoc, ArrayRef<ValueDecl*> Elts,
|
|
TypeAliasDecl *TheDecl)
|
|
: TypeBase(TypeKind::Protocol, &TheDecl->getASTContext(),
|
|
/*Dependent=*/false),
|
|
DeclContext(DeclContextKind::ProtocolType, TheDecl->getDeclContext()),
|
|
ProtocolLoc(ProtocolLoc), Elements(Elts), TheDecl(TheDecl) {
|
|
}
|
|
|
|
LValueType *LValueType::get(Type objectTy, Qual quals, ASTContext &C) {
|
|
auto key = std::make_pair(objectTy, quals.getOpaqueData());
|
|
auto it = C.Impl.LValueTypes.find(key);
|
|
if (it != C.Impl.LValueTypes.end()) return it->second;
|
|
|
|
ASTContext *canonicalContext = (objectTy->isCanonical() ? &C : nullptr);
|
|
LValueType *type = new (C) LValueType(objectTy, quals, canonicalContext);
|
|
C.Impl.LValueTypes.insert(std::make_pair(key, type));
|
|
return type;
|
|
}
|