void ParserDriver::addType(std::unique_ptr<AstType> type) {
const auto& name = type->getName();
if (const AstType* prev = translationUnit->getProgram()->getType(name)) {
Diagnostic err(Diagnostic::ERROR,
DiagnosticMessage("Redefinition of type " + toString(name), type->getSrcLoc()),
{DiagnosticMessage("Previous definition", prev->getSrcLoc())});
translationUnit->getErrorReport().addDiagnostic(err);
} else {
translationUnit->getProgram()->addType(std::move(type));
}
}
void ParserDriver::addFunctorDeclaration(std::unique_ptr<AstFunctorDeclaration> f) {
const std::string& name = f->getName();
if (AstFunctorDeclaration* prev = translationUnit->getProgram()->getFunctorDeclaration(name)) {
Diagnostic err(Diagnostic::ERROR,
DiagnosticMessage("Redefinition of functor " + toString(name), f->getSrcLoc()),
{DiagnosticMessage("Previous definition", prev->getSrcLoc())});
translationUnit->getErrorReport().addDiagnostic(err);
} else {
translationUnit->getProgram()->addFunctorDeclaration(std::move(f));
}
}
void ParserDriver::addRelation(std::unique_ptr<AstRelation> r) {
const auto& name = r->getName();
if (AstRelation* prev = translationUnit->getProgram()->getRelation(name)) {
Diagnostic err(Diagnostic::ERROR,
DiagnosticMessage("Redefinition of relation " + toString(name), r->getSrcLoc()),
{DiagnosticMessage("Previous definition", prev->getSrcLoc())});
translationUnit->getErrorReport().addDiagnostic(err);
} else {
if (!r->getStores().empty() || !r->getLoads().empty()) {
translationUnit->getErrorReport().addWarning(
"Deprecated io qualifier was used in relation " + toString(name), r->getSrcLoc());
}
translationUnit->getProgram()->addRelation(std::move(r));
}
}
void ParserDriver::addStore(std::unique_ptr<AstStore> d) {
if (dynamic_cast<AstPrintSize*>(d.get()) != nullptr) {
for (const auto& cur : translationUnit->getProgram()->getStores()) {
if (cur->getName() == d->getName() && dynamic_cast<AstPrintSize*>(cur.get()) != nullptr) {
Diagnostic err(Diagnostic::ERROR,
DiagnosticMessage(
"Redefinition of printsize directives for relation " + toString(d->getName()),
d->getSrcLoc()),
{DiagnosticMessage("Previous definition", cur->getSrcLoc())});
translationUnit->getErrorReport().addDiagnostic(err);
return;
}
}
}
translationUnit->getProgram()->addStore(std::move(d));
}
void ParserDriver::error(const std::string& msg) {
translationUnit->getErrorReport().addDiagnostic(Diagnostic(Diagnostic::ERROR, DiagnosticMessage(msg)));
}
void GoSource::resolveImportsAndPackageName(const QString &goRoot, const QString &goPath)
{
_imports.clear();
_resolvedImportDirs.clear();
_importTasks.clear();
_packageName.clear();
QFileInfo fi(_fileName);
_location = fi.absolutePath();
QStringList paths = { goPath, goRoot };
if (FileAST *ast = _translationUnit->fileAst()) {
if (ast->packageName)
_packageName = ast->packageName->ident->toString();
ImportDeclarationsVisitor visitor(_translationUnit, [&](ImportSpecAST *importSpec) {
GoSource::Import import;
if (importSpec->t_path) {
import.tokenIndex = importSpec->t_path;
import.dir = _translationUnit->tokenAt(importSpec->t_path).string->unquoted();
if (!import.dir.isEmpty()) {
int pos = import.dir.lastIndexOf('/') + 1;
import.packageName = import.dir.right(import.dir.length() - pos);
import.aliasSpecified = false;
if (importSpec->name) {
import.alias = importSpec->name->ident->toString();
if (import.alias != C_UNDERSCORE)
import.aliasSpecified = true;
} else {
import.alias = import.packageName;
}
_imports.append(import);
}
}
});
visitor(ast->importDecls);
}
std::set<QString> aliases;
for (Import &import: _imports) {
const Token &tk = _translationUnit->tokenAt(import.tokenIndex);
bool resolved = false;
for (const QString &path: paths) {
QString potentialDir = path + QStringLiteral("/src/") + import.dir;
QDir dir(potentialDir);
if (dir.exists()) {
import.resolvedDir = potentialDir;
std::pair<std::set<QString>::iterator, bool> insertResult = _resolvedImportDirs.insert(potentialDir);
if (!insertResult.second)
addDiagnosticMessage(DiagnosticMessage(DiagnosticMessage::Warning, QString(),
tk.kindAndPos.line, tk.kindAndPos.column,
QStringLiteral("Import directory duplicated"),
tk.length()));
else
_importTasks.insert(qMakePair(potentialDir, import.packageName));
resolved = true;
break;
}
}
if (!resolved)
addDiagnosticMessage(DiagnosticMessage(DiagnosticMessage::Warning, QString(),
tk.kindAndPos.line, tk.kindAndPos.column,
QStringLiteral("Unresolved import directory"),
tk.length()));
// Check aliases duplication
if (import.aliasSpecified) {
std::pair<std::set<QString>::iterator, bool> insertAliasResult = aliases.insert(import.alias);
if (!insertAliasResult.second) {
const Token &aliasTk = _translationUnit->tokenAt(import.tokenIndex - 1);
addDiagnosticMessage(DiagnosticMessage(DiagnosticMessage::Warning, QString(),
aliasTk.kindAndPos.line, aliasTk.kindAndPos.column,
QStringLiteral("Import alias duplicated"),
aliasTk.length()));
}
}
}
}
