Paweł Bylica
10 years ago
51 changed files with 10320 additions and 910 deletions
@ -1,122 +0,0 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
cpp-ethereum is free software: you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation, either version 3 of the License, or |
|||
(at your option) any later version. |
|||
cpp-ethereum is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
You should have received a copy of the GNU General Public License |
|||
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file AppContext.cpp
|
|||
* @author Yann yann@ethdev.com |
|||
* @date 2014 |
|||
* Provides access to the current QQmlApplicationEngine which is used to add QML file on the fly. |
|||
* In the future this class can be extended to add more variable related to the context of the application. |
|||
* For now AppContext provides reference to: |
|||
* - QQmlApplicationEngine |
|||
* - dev::WebThreeDirect (and dev::eth::Client) |
|||
* - KeyEventManager |
|||
*/ |
|||
|
|||
#include <QMessageBox> |
|||
#include <QClipboard> |
|||
#include <QQmlComponent> |
|||
#include <QQmlContext> |
|||
#include <QQmlApplicationEngine> |
|||
#include <QWindow> |
|||
#include "CodeModel.h" |
|||
#include "FileIo.h" |
|||
#include "ClientModel.h" |
|||
#include "CodeEditorExtensionManager.h" |
|||
#include "Exceptions.h" |
|||
#include "QEther.h" |
|||
#include "QVariableDefinition.h" |
|||
#include "HttpServer.h" |
|||
#include "AppContext.h" |
|||
#include "SortFilterProxyModel.h" |
|||
|
|||
using namespace dev; |
|||
using namespace dev::eth; |
|||
using namespace dev::mix; |
|||
|
|||
const QString c_projectFileName = "project.mix"; |
|||
|
|||
AppContext::AppContext(QQmlApplicationEngine* _engine) |
|||
{ |
|||
m_applicationEngine = _engine; |
|||
m_codeModel.reset(new CodeModel(this)); |
|||
m_clientModel.reset(new ClientModel(this)); |
|||
m_fileIo.reset(new FileIo()); |
|||
connect(QApplication::clipboard(), &QClipboard::dataChanged, [this] { emit clipboardChanged();}); |
|||
} |
|||
|
|||
AppContext::~AppContext() |
|||
{ |
|||
} |
|||
|
|||
void AppContext::load() |
|||
{ |
|||
m_applicationEngine->rootContext()->setContextProperty("appContext", this); |
|||
QFont f; |
|||
m_applicationEngine->rootContext()->setContextProperty("systemPointSize", f.pointSize()); |
|||
qmlRegisterType<FileIo>("org.ethereum.qml", 1, 0, "FileIo"); |
|||
m_applicationEngine->rootContext()->setContextProperty("codeModel", m_codeModel.get()); |
|||
m_applicationEngine->rootContext()->setContextProperty("fileIo", m_fileIo.get()); |
|||
qmlRegisterType<QEther>("org.ethereum.qml.QEther", 1, 0, "QEther"); |
|||
qmlRegisterType<QBigInt>("org.ethereum.qml.QBigInt", 1, 0, "QBigInt"); |
|||
qmlRegisterType<QVariableDeclaration>("org.ethereum.qml.QVariableDeclaration", 1, 0, "QVariableDeclaration"); |
|||
qmlRegisterType<RecordLogEntry>("org.ethereum.qml.RecordLogEntry", 1, 0, "RecordLogEntry"); |
|||
qmlRegisterType<SortFilterProxyModel>("org.ethereum.qml.SortFilterProxyModel", 1, 0, "SortFilterProxyModel"); |
|||
qmlRegisterType<QSolidityType>("org.ethereum.qml.QSolidityType", 1, 0, "QSolidityType"); |
|||
QQmlComponent projectModelComponent(m_applicationEngine, QUrl("qrc:/qml/ProjectModel.qml")); |
|||
QObject* projectModel = projectModelComponent.create(); |
|||
if (projectModelComponent.isError()) |
|||
{ |
|||
QmlLoadException exception; |
|||
for (auto const& e : projectModelComponent.errors()) |
|||
exception << QmlErrorInfo(e); |
|||
BOOST_THROW_EXCEPTION(exception); |
|||
} |
|||
m_applicationEngine->rootContext()->setContextProperty("projectModel", projectModel); |
|||
qmlRegisterType<CodeEditorExtensionManager>("CodeEditorExtensionManager", 1, 0, "CodeEditorExtensionManager"); |
|||
qmlRegisterType<HttpServer>("HttpServer", 1, 0, "HttpServer"); |
|||
|
|||
m_applicationEngine->load(QUrl("qrc:/qml/main.qml")); |
|||
QWindow *window = qobject_cast<QWindow*>(m_applicationEngine->rootObjects().at(0)); |
|||
window->setIcon(QIcon(":/res/mix_256x256x32.png")); |
|||
appLoaded(); |
|||
} |
|||
|
|||
QQmlApplicationEngine* AppContext::appEngine() |
|||
{ |
|||
return m_applicationEngine; |
|||
} |
|||
|
|||
void AppContext::displayMessageDialog(QString _title, QString _message) |
|||
{ |
|||
// TODO : move to a UI dedicated layer.
|
|||
QObject* dialogWin = m_applicationEngine->rootObjects().at(0)->findChild<QObject*>("alertMessageDialog", Qt::FindChildrenRecursively); |
|||
QObject* dialogWinComponent = m_applicationEngine->rootObjects().at(0)->findChild<QObject*>("alertMessageDialogContent", Qt::FindChildrenRecursively); |
|||
dialogWinComponent->setProperty("source", QString("qrc:/qml/BasicMessage.qml")); |
|||
dialogWin->setProperty("title", _title); |
|||
dialogWin->setProperty("width", "250"); |
|||
dialogWin->setProperty("height", "100"); |
|||
dialogWin->findChild<QObject*>("messageContent", Qt::FindChildrenRecursively)->setProperty("text", _message); |
|||
QMetaObject::invokeMethod(dialogWin, "open"); |
|||
} |
|||
|
|||
QString AppContext::clipboard() const |
|||
{ |
|||
QClipboard *clipboard = QApplication::clipboard(); |
|||
return clipboard->text(); |
|||
} |
|||
|
|||
void AppContext::toClipboard(QString _text) |
|||
{ |
|||
QClipboard *clipboard = QApplication::clipboard(); |
|||
clipboard->setText(_text); |
|||
} |
|||
@ -1,88 +0,0 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum is free software: you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation, either version 3 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
cpp-ethereum is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU General Public License |
|||
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file AppContext.h
|
|||
* @author Yann yann@ethdev.com |
|||
* @date 2014 |
|||
* Provides access to the current QQmlApplicationEngine which is used to add QML file on the fly. |
|||
* In the future this class can be extended to add more variable related to the context of the application. |
|||
* For now AppContext provides reference to: |
|||
* - QQmlApplicationEngine |
|||
* - dev::WebThreeDirect (and dev::eth::Client) |
|||
* - KeyEventManager |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <memory> |
|||
#include <QUrl> |
|||
#include <QObject> |
|||
|
|||
class QQmlApplicationEngine; |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace mix |
|||
{ |
|||
|
|||
class CodeModel; |
|||
class ClientModel; |
|||
class FileIo; |
|||
/**
|
|||
* @brief Provides access to application scope variable. |
|||
*/ |
|||
|
|||
class AppContext: public QObject |
|||
{ |
|||
Q_OBJECT |
|||
Q_PROPERTY(QString clipboard READ clipboard WRITE toClipboard NOTIFY clipboardChanged) |
|||
|
|||
public: |
|||
AppContext(QQmlApplicationEngine* _engine); |
|||
virtual ~AppContext(); |
|||
/// Load the UI from qml files
|
|||
void load(); |
|||
/// Get the current QQMLApplicationEngine instance.
|
|||
QQmlApplicationEngine* appEngine(); |
|||
/// Get code model
|
|||
CodeModel* codeModel() { return m_codeModel.get(); } |
|||
/// Get client model
|
|||
ClientModel* clientModel() { return m_clientModel.get(); } |
|||
/// Display an alert message.
|
|||
void displayMessageDialog(QString _title, QString _message); |
|||
/// Copy text to clipboard
|
|||
Q_INVOKABLE void toClipboard(QString _text); |
|||
/// Get text from clipboard
|
|||
QString clipboard() const; |
|||
|
|||
signals: |
|||
/// Triggered once components have been loaded
|
|||
void appLoaded(); |
|||
void clipboardChanged(); |
|||
|
|||
private: |
|||
QQmlApplicationEngine* m_applicationEngine; //owned by app
|
|||
std::unique_ptr<CodeModel> m_codeModel; |
|||
std::unique_ptr<ClientModel> m_clientModel; |
|||
std::unique_ptr<FileIo> m_fileIo; |
|||
|
|||
public slots: |
|||
/// Delete the current instance when application quit.
|
|||
void quitApplication() {} |
|||
}; |
|||
|
|||
} |
|||
} |
|||
@ -1,55 +1,40 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum is free software: you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation, either version 3 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
cpp-ethereum is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU General Public License |
|||
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file ConstantCompilationControl.cpp
|
|||
/** @file Clipboard.cpp
|
|||
* @author Yann yann@ethdev.com |
|||
* @date 2014 |
|||
* Ethereum IDE client. |
|||
* @date 2015 |
|||
*/ |
|||
|
|||
#include <QQmlContext> |
|||
#include <QQuickItem> |
|||
#include <QtCore/QFileInfo> |
|||
#include "Clipboard.h" |
|||
#include <QApplication> |
|||
#include <QQmlApplicationEngine> |
|||
#include <QtCore/QtCore> |
|||
#include <QDebug> |
|||
#include "StatusPane.h" |
|||
#include "QContractDefinition.h" |
|||
#include "AppContext.h" |
|||
#include "CodeModel.h" |
|||
#include <QClipboard> |
|||
|
|||
using namespace dev::mix; |
|||
|
|||
StatusPane::StatusPane(AppContext* _context): Extension(_context, ExtensionDisplayBehavior::HeaderView) |
|||
Clipboard::Clipboard() |
|||
{ |
|||
_context->appEngine()->rootContext()->setContextProperty("statusPane", this); |
|||
connect(QApplication::clipboard(), &QClipboard::dataChanged, [this] { emit clipboardChanged();}); |
|||
} |
|||
|
|||
QString StatusPane::contentUrl() const |
|||
QString Clipboard::text() const |
|||
{ |
|||
return QStringLiteral("qrc:/qml/StatusPane.qml"); |
|||
QClipboard *clipboard = QApplication::clipboard(); |
|||
return clipboard->text(); |
|||
} |
|||
|
|||
QString StatusPane::title() const |
|||
void Clipboard::setText(QString _text) |
|||
{ |
|||
return QApplication::tr("compiler"); |
|||
QClipboard *clipboard = QApplication::clipboard(); |
|||
clipboard->setText(_text); |
|||
} |
|||
|
|||
void StatusPane::start() const |
|||
{ |
|||
} |
|||
|
|||
@ -1,88 +0,0 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum is free software: you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation, either version 3 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
cpp-ethereum is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU General Public License |
|||
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file CodeEditorExtensionManager.cpp
|
|||
* @author Yann yann@ethdev.com |
|||
* @date 2014 |
|||
* Ethereum IDE client. |
|||
*/ |
|||
|
|||
#include <QQuickItem> |
|||
#include <QGraphicsObject> |
|||
#include <QQmlEngine> |
|||
#include <QQmlComponent> |
|||
#include <QQuickTextDocument> |
|||
#include "StatusPane.h" |
|||
#include "AppContext.h" |
|||
#include "MixApplication.h" |
|||
#include "CodeModel.h" |
|||
#include "ClientModel.h" |
|||
#include "CodeHighlighter.h" |
|||
#include "CodeEditorExtensionManager.h" |
|||
|
|||
using namespace dev::mix; |
|||
|
|||
CodeEditorExtensionManager::CodeEditorExtensionManager(): |
|||
m_appContext(static_cast<MixApplication*>(QApplication::instance())->context()) |
|||
{ |
|||
} |
|||
|
|||
CodeEditorExtensionManager::~CodeEditorExtensionManager() |
|||
{ |
|||
m_features.clear(); |
|||
} |
|||
|
|||
void CodeEditorExtensionManager::loadEditor(QQuickItem* _editor) |
|||
{ |
|||
if (!_editor) |
|||
return; |
|||
} |
|||
|
|||
void CodeEditorExtensionManager::initExtension(std::shared_ptr<Extension> _ext) |
|||
{ |
|||
if (!_ext->contentUrl().isEmpty()) |
|||
{ |
|||
try |
|||
{ |
|||
if (_ext->getDisplayBehavior() == ExtensionDisplayBehavior::RightView) |
|||
_ext->addTabOn(m_rightView); |
|||
if (_ext->getDisplayBehavior() == ExtensionDisplayBehavior::HeaderView) |
|||
_ext->addTabOn(m_headerView); |
|||
} |
|||
catch (...) |
|||
{ |
|||
qDebug() << "Exception when adding tab into view."; |
|||
return; |
|||
} |
|||
} |
|||
_ext->start(); |
|||
m_features.append(_ext); |
|||
} |
|||
|
|||
void CodeEditorExtensionManager::applyCodeHighlight() |
|||
{ |
|||
//TODO: reimplement
|
|||
} |
|||
|
|||
void CodeEditorExtensionManager::setRightView(QQuickItem* _rightView) |
|||
{ |
|||
m_rightView = _rightView; |
|||
} |
|||
|
|||
void CodeEditorExtensionManager::setHeaderView(QQuickItem* _headerView) |
|||
{ |
|||
m_headerView = _headerView; |
|||
} |
|||
@ -1,71 +0,0 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum is free software: you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation, either version 3 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
cpp-ethereum is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU General Public License |
|||
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file CodeEditorExtensionManager.h
|
|||
* @author Yann yann@ethdev.com |
|||
* @date 2014 |
|||
* Ethereum IDE client. |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <memory> |
|||
#include <QQuickItem> |
|||
#include <QTextDocument> |
|||
#include <QVector> |
|||
#include "StatusPane.h" |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace mix |
|||
{ |
|||
|
|||
|
|||
class AppContext; |
|||
|
|||
/**
|
|||
* @brief Init and provides connection between extensions. |
|||
*/ |
|||
class CodeEditorExtensionManager: public QObject |
|||
{ |
|||
Q_OBJECT |
|||
|
|||
Q_PROPERTY(QQuickItem* headerView MEMBER m_headerView WRITE setHeaderView) |
|||
Q_PROPERTY(QQuickItem* rightView MEMBER m_rightView WRITE setRightView) |
|||
|
|||
public: |
|||
CodeEditorExtensionManager(); |
|||
~CodeEditorExtensionManager(); |
|||
/// Initialize extension.
|
|||
void initExtension(std::shared_ptr<Extension>); |
|||
/// Set current tab view
|
|||
void setHeaderView(QQuickItem*); |
|||
/// Set current right tab view.
|
|||
void setRightView(QQuickItem*); |
|||
|
|||
private slots: |
|||
void applyCodeHighlight(); |
|||
|
|||
private: |
|||
QVector<std::shared_ptr<Extension>> m_features; |
|||
QQuickItem* m_headerView; |
|||
QQuickItem* m_rightView; |
|||
AppContext* m_appContext; |
|||
void loadEditor(QQuickItem* _editor); |
|||
}; |
|||
|
|||
} |
|||
} |
|||
@ -1,82 +0,0 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
cpp-ethereum is free software: you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation, either version 3 of the License, or |
|||
(at your option) any later version. |
|||
cpp-ethereum is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
You should have received a copy of the GNU General Public License |
|||
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file Extension.cpp
|
|||
* @author Yann yann@ethdev.com |
|||
* @date 2014 |
|||
* Ethereum IDE client. |
|||
*/ |
|||
|
|||
|
|||
#include <QMessageBox> |
|||
#include <QDebug> |
|||
#include <QQmlApplicationEngine> |
|||
|
|||
#include <libevm/VM.h> |
|||
#include <libwebthree/WebThree.h> |
|||
#include "Extension.h" |
|||
#include "AppContext.h" |
|||
|
|||
using namespace dev; |
|||
using namespace dev::mix; |
|||
|
|||
Extension::Extension(AppContext* _context) |
|||
{ |
|||
init(_context); |
|||
} |
|||
|
|||
Extension::Extension(AppContext* _context, ExtensionDisplayBehavior _displayBehavior) |
|||
{ |
|||
init(_context); |
|||
m_displayBehavior = _displayBehavior; |
|||
} |
|||
|
|||
void Extension::init(AppContext* _context) |
|||
{ |
|||
m_ctx = _context; |
|||
m_appEngine = m_ctx->appEngine(); |
|||
} |
|||
|
|||
void Extension::addTabOn(QObject* _view) |
|||
{ |
|||
if (contentUrl() == "") |
|||
return; |
|||
|
|||
QVariant returnValue; |
|||
QQmlComponent* component = new QQmlComponent( |
|||
m_appEngine, |
|||
QUrl(contentUrl()), _view); |
|||
|
|||
QMetaObject::invokeMethod(_view, "addTab", |
|||
Q_RETURN_ARG(QVariant, returnValue), |
|||
Q_ARG(QVariant, this->title()), |
|||
Q_ARG(QVariant, QVariant::fromValue(component))); |
|||
|
|||
m_view = qvariant_cast<QObject*>(returnValue); |
|||
} |
|||
|
|||
void Extension::addContentOn(QObject* _view) |
|||
{ |
|||
Q_UNUSED(_view); |
|||
if (m_displayBehavior == ExtensionDisplayBehavior::ModalDialog) |
|||
{ |
|||
QQmlComponent* component = new QQmlComponent(m_appEngine, QUrl(contentUrl()), _view); |
|||
QObject* dialogWin = m_appEngine->rootObjects().at(0)->findChild<QObject*>("dialog", Qt::FindChildrenRecursively); |
|||
QObject* dialogWinComponent = m_appEngine->rootObjects().at(0)->findChild<QObject*>("modalDialogContent", Qt::FindChildrenRecursively); |
|||
dialogWinComponent->setProperty("sourceComponent", QVariant::fromValue(component)); |
|||
dialogWin->setProperty("title", title()); |
|||
QMetaObject::invokeMethod(dialogWin, "open"); |
|||
} |
|||
//TODO add more view type.
|
|||
} |
|||
|
|||
@ -1,75 +0,0 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
cpp-ethereum is free software: you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation, either version 3 of the License, or |
|||
(at your option) any later version. |
|||
cpp-ethereum is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
You should have received a copy of the GNU General Public License |
|||
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file Extension.h
|
|||
* @author Yann yann@ethdev.com |
|||
* @date 2014 |
|||
* Ethereum IDE client. |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <QApplication> |
|||
#include <QQmlComponent> |
|||
|
|||
class QQmlApplicationEngine; |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace mix |
|||
{ |
|||
|
|||
class AppContext; |
|||
|
|||
enum ExtensionDisplayBehavior |
|||
{ |
|||
HeaderView, |
|||
RightView, |
|||
ModalDialog |
|||
}; |
|||
|
|||
|
|||
class Extension: public QObject |
|||
{ |
|||
Q_OBJECT |
|||
|
|||
public: |
|||
Extension(AppContext* _context); |
|||
Extension(AppContext* _context, ExtensionDisplayBehavior _displayBehavior); |
|||
/// Return the QML url of the view to display.
|
|||
virtual QString contentUrl() const { return ""; } |
|||
/// Return the title of this extension.
|
|||
virtual QString title() const { return ""; } |
|||
/// Initialize extension.
|
|||
virtual void start() const {} |
|||
/// Add the view define in contentUrl() in the _view QObject.
|
|||
void addContentOn(QObject* _view); |
|||
/// Add the view define in contentUrl() in the _view QObject (_view has to be a tab).
|
|||
void addTabOn(QObject* _view); |
|||
/// Modify the display behavior of this extension.
|
|||
void setDisplayBehavior(ExtensionDisplayBehavior _displayBehavior) { m_displayBehavior = _displayBehavior; } |
|||
/// Get the display behavior of thi extension.
|
|||
ExtensionDisplayBehavior getDisplayBehavior() { return m_displayBehavior; } |
|||
|
|||
protected: |
|||
QObject* m_view; |
|||
ExtensionDisplayBehavior m_displayBehavior; |
|||
AppContext* m_ctx; |
|||
QQmlApplicationEngine* m_appEngine; |
|||
|
|||
private: |
|||
void init(AppContext* _context); |
|||
}; |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,65 @@ |
|||
<RCC> |
|||
<qresource prefix="/"> |
|||
<file>qml/AlertMessageDialog.qml</file> |
|||
<file>qml/BasicMessage.qml</file> |
|||
<file>qml/BigIntValue.qml</file> |
|||
<file>qml/CallStack.qml</file> |
|||
<file>qml/CodeEditorStyle.qml</file> |
|||
<file>qml/CodeEditorView.qml</file> |
|||
<file>qml/CommonSeparator.qml</file> |
|||
<file>qml/ContractLibrary.qml</file> |
|||
<file>qml/DebugBasicInfo.qml</file> |
|||
<file>qml/DebugInfoList.qml</file> |
|||
<file>qml/Debugger.qml</file> |
|||
<file>qml/DebuggerPaneStyle.qml</file> |
|||
<file>qml/DefaultLabel.qml</file> |
|||
<file>qml/DefaultTextField.qml</file> |
|||
<file>qml/DeploymentDialog.qml</file> |
|||
<file>qml/Ether.qml</file> |
|||
<file>qml/EtherValue.qml</file> |
|||
<file>qml/FilesSection.qml</file> |
|||
<file>qml/ItemDelegateDataDump.qml</file> |
|||
<file>qml/LogsPane.qml</file> |
|||
<file>qml/LogsPaneStyle.qml</file> |
|||
<file>qml/MainContent.qml</file> |
|||
<file>qml/ModalDialog.qml</file> |
|||
<file>qml/NewProjectDialog.qml</file> |
|||
<file>qml/ProjectFilesStyle.qml</file> |
|||
<file>qml/ProjectList.qml</file> |
|||
<file>qml/ProjectModel.qml</file> |
|||
<file>qml/QBoolTypeView.qml</file> |
|||
<file>qml/QHashTypeView.qml</file> |
|||
<file>qml/QIntTypeView.qml</file> |
|||
<file>qml/QRealTypeView.qml</file> |
|||
<file>qml/QStringTypeView.qml</file> |
|||
<file>qml/QVariableDeclaration.qml</file> |
|||
<file>qml/QVariableDefinition.qml</file> |
|||
<file>qml/SourceSansProBold.qml</file> |
|||
<file>qml/SourceSansProLight.qml</file> |
|||
<file>qml/SourceSansProRegular.qml</file> |
|||
<file>qml/Splitter.qml</file> |
|||
<file>qml/StateDialog.qml</file> |
|||
<file>qml/StateDialogStyle.qml</file> |
|||
<file>qml/StateList.qml</file> |
|||
<file>qml/StateListModel.qml</file> |
|||
<file>qml/StateStyle.qml</file> |
|||
<file>qml/StatusPane.qml</file> |
|||
<file>qml/StatusPaneStyle.qml</file> |
|||
<file>qml/StepActionImage.qml</file> |
|||
<file>qml/StorageView.qml</file> |
|||
<file>qml/StructView.qml</file> |
|||
<file>qml/Style.qml</file> |
|||
<file>qml/TabStyle.qml</file> |
|||
<file>qml/TransactionDialog.qml</file> |
|||
<file>qml/TransactionLog.qml</file> |
|||
<file>qml/VariablesView.qml</file> |
|||
<file>qml/WebPreviewStyle.qml</file> |
|||
<file>qml/js/Debugger.js</file> |
|||
<file>qml/js/ErrorLocationFormater.js</file> |
|||
<file>qml/js/ProjectModel.js</file> |
|||
<file>qml/js/QEtherHelper.js</file> |
|||
<file>qml/js/TransactionHelper.js</file> |
|||
<file>qml/main.qml</file> |
|||
<file>qml/qmldir</file> |
|||
</qresource> |
|||
</RCC> |
|||
@ -0,0 +1,14 @@ |
|||
import QtQuick 2.0 |
|||
import QtQuick.Controls 1.3 |
|||
|
|||
SplitView |
|||
{ |
|||
handleDelegate: Rectangle { |
|||
width: 4 |
|||
height: 4 |
|||
color: "#cccccc" |
|||
} |
|||
} |
|||
|
|||
|
|||
|
|||
File diff suppressed because it is too large
File diff suppressed because it is too large
@ -0,0 +1,87 @@ |
|||
(function(mod) { |
|||
if (typeof exports == "object" && typeof module == "object") // CommonJS
|
|||
return mod(exports); |
|||
if (typeof define == "function" && define.amd) // AMD
|
|||
return define(["exports"], mod); |
|||
mod(tern.comment || (tern.comment = {})); |
|||
})(function(exports) { |
|||
function isSpace(ch) { |
|||
return (ch < 14 && ch > 8) || ch === 32 || ch === 160; |
|||
} |
|||
|
|||
function onOwnLine(text, pos) { |
|||
for (; pos > 0; --pos) { |
|||
var ch = text.charCodeAt(pos - 1); |
|||
if (ch == 10) break; |
|||
if (!isSpace(ch)) return false; |
|||
} |
|||
return true; |
|||
} |
|||
|
|||
// Gather comments directly before a function
|
|||
exports.commentsBefore = function(text, pos) { |
|||
var found = null, emptyLines = 0, topIsLineComment; |
|||
out: while (pos > 0) { |
|||
var prev = text.charCodeAt(pos - 1); |
|||
if (prev == 10) { |
|||
for (var scan = --pos, sawNonWS = false; scan > 0; --scan) { |
|||
prev = text.charCodeAt(scan - 1); |
|||
if (prev == 47 && text.charCodeAt(scan - 2) == 47) { |
|||
if (!onOwnLine(text, scan - 2)) break out; |
|||
var content = text.slice(scan, pos); |
|||
if (!emptyLines && topIsLineComment) found[0] = content + "\n" + found[0]; |
|||
else (found || (found = [])).unshift(content); |
|||
topIsLineComment = true; |
|||
emptyLines = 0; |
|||
pos = scan - 2; |
|||
break; |
|||
} else if (prev == 10) { |
|||
if (!sawNonWS && ++emptyLines > 1) break out; |
|||
break; |
|||
} else if (!sawNonWS && !isSpace(prev)) { |
|||
sawNonWS = true; |
|||
} |
|||
} |
|||
} else if (prev == 47 && text.charCodeAt(pos - 2) == 42) { |
|||
for (var scan = pos - 2; scan > 1; --scan) { |
|||
if (text.charCodeAt(scan - 1) == 42 && text.charCodeAt(scan - 2) == 47) { |
|||
if (!onOwnLine(text, scan - 2)) break out; |
|||
(found || (found = [])).unshift(text.slice(scan, pos - 2)); |
|||
topIsLineComment = false; |
|||
emptyLines = 0; |
|||
break; |
|||
} |
|||
} |
|||
pos = scan - 2; |
|||
} else if (isSpace(prev)) { |
|||
--pos; |
|||
} else { |
|||
break; |
|||
} |
|||
} |
|||
return found; |
|||
}; |
|||
|
|||
exports.commentAfter = function(text, pos) { |
|||
while (pos < text.length) { |
|||
var next = text.charCodeAt(pos); |
|||
if (next == 47) { |
|||
var after = text.charCodeAt(pos + 1), end; |
|||
if (after == 47) // line comment
|
|||
end = text.indexOf("\n", pos + 2); |
|||
else if (after == 42) // block comment
|
|||
end = text.indexOf("*/", pos + 2); |
|||
else |
|||
return; |
|||
return text.slice(pos + 2, end < 0 ? text.length : end); |
|||
} else if (isSpace(next)) { |
|||
++pos; |
|||
} |
|||
} |
|||
}; |
|||
|
|||
exports.ensureCommentsBefore = function(text, node) { |
|||
if (node.hasOwnProperty("commentsBefore")) return node.commentsBefore; |
|||
return node.commentsBefore = exports.commentsBefore(text, node.start); |
|||
}; |
|||
}); |
|||
@ -0,0 +1,547 @@ |
|||
// Type description parser
|
|||
//
|
|||
// Type description JSON files (such as ecma5.json and browser.json)
|
|||
// are used to
|
|||
//
|
|||
// A) describe types that come from native code
|
|||
//
|
|||
// B) to cheaply load the types for big libraries, or libraries that
|
|||
// can't be inferred well
|
|||
|
|||
(function(mod) { |
|||
if (typeof exports == "object" && typeof module == "object") // CommonJS
|
|||
return exports.init = mod; |
|||
if (typeof define == "function" && define.amd) // AMD
|
|||
return define({init: mod}); |
|||
tern.def = {init: mod}; |
|||
})(function(exports, infer) { |
|||
"use strict"; |
|||
|
|||
function hop(obj, prop) { |
|||
return Object.prototype.hasOwnProperty.call(obj, prop); |
|||
} |
|||
|
|||
var TypeParser = exports.TypeParser = function(spec, start, base, forceNew) { |
|||
this.pos = start || 0; |
|||
this.spec = spec; |
|||
this.base = base; |
|||
this.forceNew = forceNew; |
|||
}; |
|||
TypeParser.prototype = { |
|||
eat: function(str) { |
|||
if (str.length == 1 ? this.spec.charAt(this.pos) == str : this.spec.indexOf(str, this.pos) == this.pos) { |
|||
this.pos += str.length; |
|||
return true; |
|||
} |
|||
}, |
|||
word: function(re) { |
|||
var word = "", ch, re = re || /[\w$]/; |
|||
while ((ch = this.spec.charAt(this.pos)) && re.test(ch)) { word += ch; ++this.pos; } |
|||
return word; |
|||
}, |
|||
error: function() { |
|||
throw new Error("Unrecognized type spec: " + this.spec + " (at " + this.pos + ")"); |
|||
}, |
|||
parseFnType: function(name, top) { |
|||
var args = [], names = []; |
|||
if (!this.eat(")")) for (var i = 0; ; ++i) { |
|||
var colon = this.spec.indexOf(": ", this.pos), argname; |
|||
if (colon != -1) { |
|||
argname = this.spec.slice(this.pos, colon); |
|||
if (/^[$\w?]+$/.test(argname)) |
|||
this.pos = colon + 2; |
|||
else |
|||
argname = null; |
|||
} |
|||
names.push(argname); |
|||
args.push(this.parseType()); |
|||
if (!this.eat(", ")) { |
|||
this.eat(")") || this.error(); |
|||
break; |
|||
} |
|||
} |
|||
var retType, computeRet, computeRetStart, fn; |
|||
if (this.eat(" -> ")) { |
|||
if (top && this.spec.indexOf("!", this.pos) > -1) { |
|||
retType = infer.ANull; |
|||
computeRetStart = this.pos; |
|||
computeRet = this.parseRetType(); |
|||
} else retType = this.parseType(); |
|||
} else retType = infer.ANull; |
|||
if (top && (fn = this.base)) |
|||
infer.Fn.call(this.base, name, infer.ANull, args, names, retType); |
|||
else |
|||
fn = new infer.Fn(name, infer.ANull, args, names, retType); |
|||
if (computeRet) fn.computeRet = computeRet; |
|||
if (computeRetStart != null) fn.computeRetSource = this.spec.slice(computeRetStart, this.pos); |
|||
return fn; |
|||
}, |
|||
parseType: function(name, top) { |
|||
var type, union = false; |
|||
for (;;) { |
|||
var inner = this.parseTypeInner(name, top); |
|||
if (union) inner.propagate(union); |
|||
else type = inner; |
|||
if (!this.eat("|")) break; |
|||
if (!union) { |
|||
union = new infer.AVal; |
|||
type.propagate(union); |
|||
type = union; |
|||
} |
|||
} |
|||
return type; |
|||
}, |
|||
parseTypeInner: function(name, top) { |
|||
if (this.eat("fn(")) { |
|||
return this.parseFnType(name, top); |
|||
} else if (this.eat("[")) { |
|||
var inner = this.parseType(); |
|||
this.eat("]") || this.error(); |
|||
if (top && this.base) { |
|||
infer.Arr.call(this.base, inner); |
|||
return this.base; |
|||
} |
|||
return new infer.Arr(inner); |
|||
} else if (this.eat("+")) { |
|||
var path = this.word(/[\w$<>\.!]/); |
|||
var base = parsePath(path + ".prototype"); |
|||
if (!(base instanceof infer.Obj)) base = parsePath(path); |
|||
if (!(base instanceof infer.Obj)) return base; |
|||
if (top && this.forceNew) return new infer.Obj(base); |
|||
return infer.getInstance(base); |
|||
} else if (this.eat("?")) { |
|||
return infer.ANull; |
|||
} else { |
|||
return this.fromWord(this.word(/[\w$<>\.!`]/)); |
|||
} |
|||
}, |
|||
fromWord: function(spec) { |
|||
var cx = infer.cx(); |
|||
switch (spec) { |
|||
case "number": return cx.num; |
|||
case "string": return cx.str; |
|||
case "bool": return cx.bool; |
|||
case "<top>": return cx.topScope; |
|||
} |
|||
if (cx.localDefs && spec in cx.localDefs) return cx.localDefs[spec]; |
|||
return parsePath(spec); |
|||
}, |
|||
parseBaseRetType: function() { |
|||
if (this.eat("[")) { |
|||
var inner = this.parseRetType(); |
|||
this.eat("]") || this.error(); |
|||
return function(self, args) { return new infer.Arr(inner(self, args)); }; |
|||
} else if (this.eat("+")) { |
|||
var base = this.parseRetType(); |
|||
var result = function(self, args) { |
|||
var proto = base(self, args); |
|||
if (proto instanceof infer.Fn && proto.hasProp("prototype")) |
|||
proto = proto.getProp("prototype").getObjType(); |
|||
if (!(proto instanceof infer.Obj)) return proto; |
|||
return new infer.Obj(proto); |
|||
}; |
|||
if (this.eat("[")) return this.parsePoly(result); |
|||
return result; |
|||
} else if (this.eat("!")) { |
|||
var arg = this.word(/\d/); |
|||
if (arg) { |
|||
arg = Number(arg); |
|||
return function(_self, args) {return args[arg] || infer.ANull;}; |
|||
} else if (this.eat("this")) { |
|||
return function(self) {return self;}; |
|||
} else if (this.eat("custom:")) { |
|||
var fname = this.word(/[\w$]/); |
|||
return customFunctions[fname] || function() { return infer.ANull; }; |
|||
} else { |
|||
return this.fromWord("!" + arg + this.word(/[\w$<>\.!]/)); |
|||
} |
|||
} |
|||
var t = this.parseType(); |
|||
return function(){return t;}; |
|||
}, |
|||
extendRetType: function(base) { |
|||
var propName = this.word(/[\w<>$!]/) || this.error(); |
|||
if (propName == "!ret") return function(self, args) { |
|||
var lhs = base(self, args); |
|||
if (lhs.retval) return lhs.retval; |
|||
var rv = new infer.AVal; |
|||
lhs.propagate(new infer.IsCallee(infer.ANull, [], null, rv)); |
|||
return rv; |
|||
}; |
|||
return function(self, args) {return base(self, args).getProp(propName);}; |
|||
}, |
|||
parsePoly: function(base) { |
|||
var propName = "<i>", match; |
|||
if (match = this.spec.slice(this.pos).match(/^\s*(\w+)\s*=\s*/)) { |
|||
propName = match[1]; |
|||
this.pos += match[0].length; |
|||
} |
|||
var value = this.parseRetType(); |
|||
if (!this.eat("]")) this.error(); |
|||
return function(self, args) { |
|||
var instance = base(self, args); |
|||
if (instance instanceof infer.Obj) |
|||
value(self, args).propagate(instance.defProp(propName)); |
|||
return instance; |
|||
}; |
|||
}, |
|||
parseRetType: function() { |
|||
var tp = this.parseBaseRetType(); |
|||
while (this.eat(".")) tp = this.extendRetType(tp); |
|||
return tp; |
|||
} |
|||
}; |
|||
|
|||
function parseType(spec, name, base, forceNew) { |
|||
var type = new TypeParser(spec, null, base, forceNew).parseType(name, true); |
|||
if (/^fn\(/.test(spec)) for (var i = 0; i < type.args.length; ++i) (function(i) { |
|||
var arg = type.args[i]; |
|||
if (arg instanceof infer.Fn && arg.args && arg.args.length) addEffect(type, function(_self, fArgs) { |
|||
var fArg = fArgs[i]; |
|||
if (fArg) fArg.propagate(new infer.IsCallee(infer.cx().topScope, arg.args, null, infer.ANull)); |
|||
}); |
|||
})(i); |
|||
return type; |
|||
} |
|||
|
|||
function addEffect(fn, handler, replaceRet) { |
|||
var oldCmp = fn.computeRet, rv = fn.retval; |
|||
fn.computeRet = function(self, args, argNodes) { |
|||
var handled = handler(self, args, argNodes); |
|||
var old = oldCmp ? oldCmp(self, args, argNodes) : rv; |
|||
return replaceRet ? handled : old; |
|||
}; |
|||
} |
|||
|
|||
var parseEffect = exports.parseEffect = function(effect, fn) { |
|||
var m; |
|||
if (effect.indexOf("propagate ") == 0) { |
|||
var p = new TypeParser(effect, 10); |
|||
var getOrigin = p.parseRetType(); |
|||
if (!p.eat(" ")) p.error(); |
|||
var getTarget = p.parseRetType(); |
|||
addEffect(fn, function(self, args) { |
|||
getOrigin(self, args).propagate(getTarget(self, args)); |
|||
}); |
|||
} else if (effect.indexOf("call ") == 0) { |
|||
var andRet = effect.indexOf("and return ", 5) == 5; |
|||
var p = new TypeParser(effect, andRet ? 16 : 5); |
|||
var getCallee = p.parseRetType(), getSelf = null, getArgs = []; |
|||
if (p.eat(" this=")) getSelf = p.parseRetType(); |
|||
while (p.eat(" ")) getArgs.push(p.parseRetType()); |
|||
addEffect(fn, function(self, args) { |
|||
var callee = getCallee(self, args); |
|||
var slf = getSelf ? getSelf(self, args) : infer.ANull, as = []; |
|||
for (var i = 0; i < getArgs.length; ++i) as.push(getArgs[i](self, args)); |
|||
var result = andRet ? new infer.AVal : infer.ANull; |
|||
callee.propagate(new infer.IsCallee(slf, as, null, result)); |
|||
return result; |
|||
}, andRet); |
|||
} else if (m = effect.match(/^custom (\S+)\s*(.*)/)) { |
|||
var customFunc = customFunctions[m[1]]; |
|||
if (customFunc) addEffect(fn, m[2] ? customFunc(m[2]) : customFunc); |
|||
} else if (effect.indexOf("copy ") == 0) { |
|||
var p = new TypeParser(effect, 5); |
|||
var getFrom = p.parseRetType(); |
|||
p.eat(" "); |
|||
var getTo = p.parseRetType(); |
|||
addEffect(fn, function(self, args) { |
|||
var from = getFrom(self, args), to = getTo(self, args); |
|||
from.forAllProps(function(prop, val, local) { |
|||
if (local && prop != "<i>") |
|||
to.propagate(new infer.PropHasSubset(prop, val)); |
|||
}); |
|||
}); |
|||
} else { |
|||
throw new Error("Unknown effect type: " + effect); |
|||
} |
|||
}; |
|||
|
|||
var currentTopScope; |
|||
|
|||
var parsePath = exports.parsePath = function(path, scope) { |
|||
var cx = infer.cx(), cached = cx.paths[path], origPath = path; |
|||
if (cached != null) return cached; |
|||
cx.paths[path] = infer.ANull; |
|||
|
|||
var base = scope || currentTopScope || cx.topScope; |
|||
|
|||
if (cx.localDefs) for (var name in cx.localDefs) { |
|||
if (path.indexOf(name) == 0) { |
|||
if (path == name) return cx.paths[path] = cx.localDefs[path]; |
|||
if (path.charAt(name.length) == ".") { |
|||
base = cx.localDefs[name]; |
|||
path = path.slice(name.length + 1); |
|||
break; |
|||
} |
|||
} |
|||
} |
|||
|
|||
var parts = path.split("."); |
|||
for (var i = 0; i < parts.length && base != infer.ANull; ++i) { |
|||
var prop = parts[i]; |
|||
if (prop.charAt(0) == "!") { |
|||
if (prop == "!proto") { |
|||
base = (base instanceof infer.Obj && base.proto) || infer.ANull; |
|||
} else { |
|||
var fn = base.getFunctionType(); |
|||
if (!fn) { |
|||
base = infer.ANull; |
|||
} else if (prop == "!ret") { |
|||
base = fn.retval && fn.retval.getType(false) || infer.ANull; |
|||
} else { |
|||
var arg = fn.args && fn.args[Number(prop.slice(1))]; |
|||
base = (arg && arg.getType(false)) || infer.ANull; |
|||
} |
|||
} |
|||
} else if (base instanceof infer.Obj) { |
|||
var propVal = (prop == "prototype" && base instanceof infer.Fn) ? base.getProp(prop) : base.props[prop]; |
|||
if (!propVal || propVal.isEmpty()) |
|||
base = infer.ANull; |
|||
else |
|||
base = propVal.types[0]; |
|||
} |
|||
} |
|||
// Uncomment this to get feedback on your poorly written .json files
|
|||
// if (base == infer.ANull) console.error("bad path: " + origPath + " (" + cx.curOrigin + ")");
|
|||
cx.paths[origPath] = base == infer.ANull ? null : base; |
|||
return base; |
|||
}; |
|||
|
|||
function emptyObj(ctor) { |
|||
var empty = Object.create(ctor.prototype); |
|||
empty.props = Object.create(null); |
|||
empty.isShell = true; |
|||
return empty; |
|||
} |
|||
|
|||
function isSimpleAnnotation(spec) { |
|||
if (!spec["!type"] || /^(fn\(|\[)/.test(spec["!type"])) return false; |
|||
for (var prop in spec) |
|||
if (prop != "!type" && prop != "!doc" && prop != "!url" && prop != "!span" && prop != "!data") |
|||
return false; |
|||
return true; |
|||
} |
|||
|
|||
function passOne(base, spec, path) { |
|||
if (!base) { |
|||
var tp = spec["!type"]; |
|||
if (tp) { |
|||
if (/^fn\(/.test(tp)) base = emptyObj(infer.Fn); |
|||
else if (tp.charAt(0) == "[") base = emptyObj(infer.Arr); |
|||
else throw new Error("Invalid !type spec: " + tp); |
|||
} else if (spec["!stdProto"]) { |
|||
base = infer.cx().protos[spec["!stdProto"]]; |
|||
} else { |
|||
base = emptyObj(infer.Obj); |
|||
} |
|||
base.name = path; |
|||
} |
|||
|
|||
for (var name in spec) if (hop(spec, name) && name.charCodeAt(0) != 33) { |
|||
var inner = spec[name]; |
|||
if (typeof inner == "string" || isSimpleAnnotation(inner)) continue; |
|||
var prop = base.defProp(name); |
|||
passOne(prop.getObjType(), inner, path ? path + "." + name : name).propagate(prop); |
|||
} |
|||
return base; |
|||
} |
|||
|
|||
function passTwo(base, spec, path) { |
|||
if (base.isShell) { |
|||
delete base.isShell; |
|||
var tp = spec["!type"]; |
|||
if (tp) { |
|||
parseType(tp, path, base); |
|||
} else { |
|||
var proto = spec["!proto"] && parseType(spec["!proto"]); |
|||
infer.Obj.call(base, proto instanceof infer.Obj ? proto : true, path); |
|||
} |
|||
} |
|||
|
|||
var effects = spec["!effects"]; |
|||
if (effects && base instanceof infer.Fn) for (var i = 0; i < effects.length; ++i) |
|||
parseEffect(effects[i], base); |
|||
copyInfo(spec, base); |
|||
|
|||
for (var name in spec) if (hop(spec, name) && name.charCodeAt(0) != 33) { |
|||
var inner = spec[name], known = base.defProp(name), innerPath = path ? path + "." + name : name; |
|||
if (typeof inner == "string") { |
|||
if (known.isEmpty()) parseType(inner, innerPath).propagate(known); |
|||
} else { |
|||
if (!isSimpleAnnotation(inner)) |
|||
passTwo(known.getObjType(), inner, innerPath); |
|||
else if (known.isEmpty()) |
|||
parseType(inner["!type"], innerPath, null, true).propagate(known); |
|||
else |
|||
continue; |
|||
if (inner["!doc"]) known.doc = inner["!doc"]; |
|||
if (inner["!url"]) known.url = inner["!url"]; |
|||
if (inner["!span"]) known.span = inner["!span"]; |
|||
} |
|||
} |
|||
return base; |
|||
} |
|||
|
|||
function copyInfo(spec, type) { |
|||
if (spec["!doc"]) type.doc = spec["!doc"]; |
|||
if (spec["!url"]) type.url = spec["!url"]; |
|||
if (spec["!span"]) type.span = spec["!span"]; |
|||
if (spec["!data"]) type.metaData = spec["!data"]; |
|||
} |
|||
|
|||
function runPasses(type, arg) { |
|||
var parent = infer.cx().parent, pass = parent && parent.passes && parent.passes[type]; |
|||
if (pass) for (var i = 0; i < pass.length; i++) pass[i](arg); |
|||
} |
|||
|
|||
function doLoadEnvironment(data, scope) { |
|||
var cx = infer.cx(); |
|||
|
|||
infer.addOrigin(cx.curOrigin = data["!name"] || "env#" + cx.origins.length); |
|||
cx.localDefs = cx.definitions[cx.curOrigin] = Object.create(null); |
|||
|
|||
runPasses("preLoadDef", data); |
|||
|
|||
passOne(scope, data); |
|||
|
|||
var def = data["!define"]; |
|||
if (def) { |
|||
for (var name in def) { |
|||
var spec = def[name]; |
|||
cx.localDefs[name] = typeof spec == "string" ? parsePath(spec) : passOne(null, spec, name); |
|||
} |
|||
for (var name in def) { |
|||
var spec = def[name]; |
|||
if (typeof spec != "string") passTwo(cx.localDefs[name], def[name], name); |
|||
} |
|||
} |
|||
|
|||
passTwo(scope, data); |
|||
|
|||
runPasses("postLoadDef", data); |
|||
|
|||
cx.curOrigin = cx.localDefs = null; |
|||
} |
|||
|
|||
exports.load = function(data, scope) { |
|||
if (!scope) scope = infer.cx().topScope; |
|||
var oldScope = currentTopScope; |
|||
currentTopScope = scope; |
|||
try { |
|||
doLoadEnvironment(data, scope); |
|||
} finally { |
|||
currentTopScope = oldScope; |
|||
} |
|||
}; |
|||
|
|||
exports.parse = function(data, origin, path) { |
|||
var cx = infer.cx(); |
|||
if (origin) { |
|||
cx.origin = origin; |
|||
cx.localDefs = cx.definitions[origin]; |
|||
} |
|||
|
|||
try { |
|||
if (typeof data == "string") |
|||
return parseType(data, path); |
|||
else |
|||
return passTwo(passOne(null, data, path), data, path); |
|||
} finally { |
|||
if (origin) cx.origin = cx.localDefs = null; |
|||
} |
|||
}; |
|||
|
|||
// Used to register custom logic for more involved effect or type
|
|||
// computation.
|
|||
var customFunctions = Object.create(null); |
|||
infer.registerFunction = function(name, f) { customFunctions[name] = f; }; |
|||
|
|||
var IsCreated = infer.constraint("created, target, spec", { |
|||
addType: function(tp) { |
|||
if (tp instanceof infer.Obj && this.created++ < 5) { |
|||
var derived = new infer.Obj(tp), spec = this.spec; |
|||
if (spec instanceof infer.AVal) spec = spec.getObjType(false); |
|||
if (spec instanceof infer.Obj) for (var prop in spec.props) { |
|||
var cur = spec.props[prop].types[0]; |
|||
var p = derived.defProp(prop); |
|||
if (cur && cur instanceof infer.Obj && cur.props.value) { |
|||
var vtp = cur.props.value.getType(false); |
|||
if (vtp) p.addType(vtp); |
|||
} |
|||
} |
|||
this.target.addType(derived); |
|||
} |
|||
} |
|||
}); |
|||
|
|||
infer.registerFunction("Object_create", function(_self, args, argNodes) { |
|||
if (argNodes && argNodes.length && argNodes[0].type == "Literal" && argNodes[0].value == null) |
|||
return new infer.Obj(); |
|||
|
|||
var result = new infer.AVal; |
|||
if (args[0]) args[0].propagate(new IsCreated(0, result, args[1])); |
|||
return result; |
|||
}); |
|||
|
|||
var PropSpec = infer.constraint("target", { |
|||
addType: function(tp) { |
|||
if (!(tp instanceof infer.Obj)) return; |
|||
if (tp.hasProp("value")) |
|||
tp.getProp("value").propagate(this.target); |
|||
else if (tp.hasProp("get")) |
|||
tp.getProp("get").propagate(new infer.IsCallee(infer.ANull, [], null, this.target)); |
|||
} |
|||
}); |
|||
|
|||
infer.registerFunction("Object_defineProperty", function(_self, args, argNodes) { |
|||
if (argNodes && argNodes.length >= 3 && argNodes[1].type == "Literal" && |
|||
typeof argNodes[1].value == "string") { |
|||
var obj = args[0], connect = new infer.AVal; |
|||
obj.propagate(new infer.PropHasSubset(argNodes[1].value, connect, argNodes[1])); |
|||
args[2].propagate(new PropSpec(connect)); |
|||
} |
|||
return infer.ANull; |
|||
}); |
|||
|
|||
var IsBound = infer.constraint("self, args, target", { |
|||
addType: function(tp) { |
|||
if (!(tp instanceof infer.Fn)) return; |
|||
this.target.addType(new infer.Fn(tp.name, tp.self, tp.args.slice(this.args.length), |
|||
tp.argNames.slice(this.args.length), tp.retval)); |
|||
this.self.propagate(tp.self); |
|||
for (var i = 0; i < Math.min(tp.args.length, this.args.length); ++i) |
|||
this.args[i].propagate(tp.args[i]); |
|||
} |
|||
}); |
|||
|
|||
infer.registerFunction("Function_bind", function(self, args) { |
|||
if (!args.length) return infer.ANull; |
|||
var result = new infer.AVal; |
|||
self.propagate(new IsBound(args[0], args.slice(1), result)); |
|||
return result; |
|||
}); |
|||
|
|||
infer.registerFunction("Array_ctor", function(_self, args) { |
|||
var arr = new infer.Arr; |
|||
if (args.length != 1 || !args[0].hasType(infer.cx().num)) { |
|||
var content = arr.getProp("<i>"); |
|||
for (var i = 0; i < args.length; ++i) args[i].propagate(content); |
|||
} |
|||
return arr; |
|||
}); |
|||
|
|||
infer.registerFunction("Promise_ctor", function(_self, args, argNodes) { |
|||
if (args.length < 1) return infer.ANull; |
|||
var self = new infer.Obj(infer.cx().definitions.ecma6["Promise.prototype"]); |
|||
var valProp = self.defProp("value", argNodes && argNodes[0]); |
|||
var valArg = new infer.AVal; |
|||
valArg.propagate(valProp); |
|||
var exec = new infer.Fn("execute", infer.ANull, [valArg], ["value"], infer.ANull); |
|||
var reject = infer.cx().definitions.ecma6.promiseReject; |
|||
args[0].propagate(new infer.IsCallee(infer.ANull, [exec, reject], null, infer.ANull)); |
|||
return self; |
|||
}); |
|||
|
|||
return exports; |
|||
}); |
|||
@ -0,0 +1,402 @@ |
|||
// Parses comments above variable declarations, function declarations,
|
|||
// and object properties as docstrings and JSDoc-style type
|
|||
// annotations.
|
|||
|
|||
(function(mod) { |
|||
if (typeof exports == "object" && typeof module == "object") // CommonJS
|
|||
return mod(require("../lib/infer"), require("../lib/tern"), require("../lib/comment"), |
|||
require("acorn/acorn"), require("acorn/util/walk")); |
|||
if (typeof define == "function" && define.amd) // AMD
|
|||
return define(["../lib/infer", "../lib/tern", "../lib/comment", "acorn/acorn", "acorn/util/walk"], mod); |
|||
mod(tern, tern, tern.comment, acorn, acorn.walk); |
|||
})(function(infer, tern, comment, acorn, walk) { |
|||
"use strict"; |
|||
|
|||
var WG_MADEUP = 1, WG_STRONG = 101; |
|||
|
|||
tern.registerPlugin("doc_comment", function(server, options) { |
|||
server.jsdocTypedefs = Object.create(null); |
|||
server.on("reset", function() { |
|||
server.jsdocTypedefs = Object.create(null); |
|||
}); |
|||
server._docComment = { |
|||
weight: options && options.strong ? WG_STRONG : undefined, |
|||
fullDocs: options && options.fullDocs |
|||
}; |
|||
|
|||
return { |
|||
passes: { |
|||
postParse: postParse, |
|||
postInfer: postInfer, |
|||
postLoadDef: postLoadDef |
|||
} |
|||
}; |
|||
}); |
|||
|
|||
function postParse(ast, text) { |
|||
function attachComments(node) { comment.ensureCommentsBefore(text, node); } |
|||
|
|||
walk.simple(ast, { |
|||
VariableDeclaration: attachComments, |
|||
FunctionDeclaration: attachComments, |
|||
AssignmentExpression: function(node) { |
|||
if (node.operator == "=") attachComments(node); |
|||
}, |
|||
ObjectExpression: function(node) { |
|||
for (var i = 0; i < node.properties.length; ++i) |
|||
attachComments(node.properties[i]); |
|||
}, |
|||
CallExpression: function(node) { |
|||
if (isDefinePropertyCall(node)) attachComments(node); |
|||
} |
|||
}); |
|||
} |
|||
|
|||
function isDefinePropertyCall(node) { |
|||
return node.callee.type == "MemberExpression" && |
|||
node.callee.object.name == "Object" && |
|||
node.callee.property.name == "defineProperty" && |
|||
node.arguments.length >= 3 && |
|||
typeof node.arguments[1].value == "string"; |
|||
} |
|||
|
|||
function postInfer(ast, scope) { |
|||
jsdocParseTypedefs(ast.sourceFile.text, scope); |
|||
|
|||
walk.simple(ast, { |
|||
VariableDeclaration: function(node, scope) { |
|||
if (node.commentsBefore) |
|||
interpretComments(node, node.commentsBefore, scope, |
|||
scope.getProp(node.declarations[0].id.name)); |
|||
}, |
|||
FunctionDeclaration: function(node, scope) { |
|||
if (node.commentsBefore) |
|||
interpretComments(node, node.commentsBefore, scope, |
|||
scope.getProp(node.id.name), |
|||
node.body.scope.fnType); |
|||
}, |
|||
AssignmentExpression: function(node, scope) { |
|||
if (node.commentsBefore) |
|||
interpretComments(node, node.commentsBefore, scope, |
|||
infer.expressionType({node: node.left, state: scope})); |
|||
}, |
|||
ObjectExpression: function(node, scope) { |
|||
for (var i = 0; i < node.properties.length; ++i) { |
|||
var prop = node.properties[i]; |
|||
if (prop.commentsBefore) |
|||
interpretComments(prop, prop.commentsBefore, scope, |
|||
node.objType.getProp(prop.key.name)); |
|||
} |
|||
}, |
|||
CallExpression: function(node, scope) { |
|||
if (node.commentsBefore && isDefinePropertyCall(node)) { |
|||
var type = infer.expressionType({node: node.arguments[0], state: scope}).getObjType(); |
|||
if (type && type instanceof infer.Obj) { |
|||
var prop = type.props[node.arguments[1].value]; |
|||
if (prop) interpretComments(node, node.commentsBefore, scope, prop); |
|||
} |
|||
} |
|||
} |
|||
}, infer.searchVisitor, scope); |
|||
} |
|||
|
|||
function postLoadDef(data) { |
|||
var defs = data["!typedef"]; |
|||
var cx = infer.cx(), orig = data["!name"]; |
|||
if (defs) for (var name in defs) |
|||
cx.parent.jsdocTypedefs[name] = |
|||
maybeInstance(infer.def.parse(defs[name], orig, name), name); |
|||
} |
|||
|
|||
// COMMENT INTERPRETATION
|
|||
|
|||
function interpretComments(node, comments, scope, aval, type) { |
|||
jsdocInterpretComments(node, scope, aval, comments); |
|||
var cx = infer.cx(); |
|||
|
|||
if (!type && aval instanceof infer.AVal && aval.types.length) { |
|||
type = aval.types[aval.types.length - 1]; |
|||
if (!(type instanceof infer.Obj) || type.origin != cx.curOrigin || type.doc) |
|||
type = null; |
|||
} |
|||
|
|||
var result = comments[comments.length - 1]; |
|||
if (cx.parent._docComment.fullDocs) { |
|||
result = result.trim().replace(/\n[ \t]*\* ?/g, "\n"); |
|||
} else { |
|||
var dot = result.search(/\.\s/); |
|||
if (dot > 5) result = result.slice(0, dot + 1); |
|||
result = result.trim().replace(/\s*\n\s*\*\s*|\s{1,}/g, " "); |
|||
} |
|||
result = result.replace(/^\s*\*+\s*/, ""); |
|||
|
|||
if (aval instanceof infer.AVal) aval.doc = result; |
|||
if (type) type.doc = result; |
|||
} |
|||
|
|||
// Parses a subset of JSDoc-style comments in order to include the
|
|||
// explicitly defined types in the analysis.
|
|||
|
|||
function skipSpace(str, pos) { |
|||
while (/\s/.test(str.charAt(pos))) ++pos; |
|||
return pos; |
|||
} |
|||
|
|||
function isIdentifier(string) { |
|||
if (!acorn.isIdentifierStart(string.charCodeAt(0))) return false; |
|||
for (var i = 1; i < string.length; i++) |
|||
if (!acorn.isIdentifierChar(string.charCodeAt(i))) return false; |
|||
return true; |
|||
} |
|||
|
|||
function parseLabelList(scope, str, pos, close) { |
|||
var labels = [], types = [], madeUp = false; |
|||
for (var first = true; ; first = false) { |
|||
pos = skipSpace(str, pos); |
|||
if (first && str.charAt(pos) == close) break; |
|||
var colon = str.indexOf(":", pos); |
|||
if (colon < 0) return null; |
|||
var label = str.slice(pos, colon); |
|||
if (!isIdentifier(label)) return null; |
|||
labels.push(label); |
|||
pos = colon + 1; |
|||
var type = parseType(scope, str, pos); |
|||
if (!type) return null; |
|||
pos = type.end; |
|||
madeUp = madeUp || type.madeUp; |
|||
types.push(type.type); |
|||
pos = skipSpace(str, pos); |
|||
var next = str.charAt(pos); |
|||
++pos; |
|||
if (next == close) break; |
|||
if (next != ",") return null; |
|||
} |
|||
return {labels: labels, types: types, end: pos, madeUp: madeUp}; |
|||
} |
|||
|
|||
function parseType(scope, str, pos) { |
|||
var type, union = false, madeUp = false; |
|||
for (;;) { |
|||
var inner = parseTypeInner(scope, str, pos); |
|||
if (!inner) return null; |
|||
madeUp = madeUp || inner.madeUp; |
|||
if (union) inner.type.propagate(union); |
|||
else type = inner.type; |
|||
pos = skipSpace(str, inner.end); |
|||
if (str.charAt(pos) != "|") break; |
|||
pos++; |
|||
if (!union) { |
|||
union = new infer.AVal; |
|||
type.propagate(union); |
|||
type = union; |
|||
} |
|||
} |
|||
var isOptional = false; |
|||
if (str.charAt(pos) == "=") { |
|||
++pos; |
|||
isOptional = true; |
|||
} |
|||
return {type: type, end: pos, isOptional: isOptional, madeUp: madeUp}; |
|||
} |
|||
|
|||
function parseTypeInner(scope, str, pos) { |
|||
pos = skipSpace(str, pos); |
|||
var type, madeUp = false; |
|||
|
|||
if (str.indexOf("function(", pos) == pos) { |
|||
var args = parseLabelList(scope, str, pos + 9, ")"), ret = infer.ANull; |
|||
if (!args) return null; |
|||
pos = skipSpace(str, args.end); |
|||
if (str.charAt(pos) == ":") { |
|||
++pos; |
|||
var retType = parseType(scope, str, pos + 1); |
|||
if (!retType) return null; |
|||
pos = retType.end; |
|||
ret = retType.type; |
|||
madeUp = retType.madeUp; |
|||
} |
|||
type = new infer.Fn(null, infer.ANull, args.types, args.labels, ret); |
|||
} else if (str.charAt(pos) == "[") { |
|||
var inner = parseType(scope, str, pos + 1); |
|||
if (!inner) return null; |
|||
pos = skipSpace(str, inner.end); |
|||
madeUp = inner.madeUp; |
|||
if (str.charAt(pos) != "]") return null; |
|||
++pos; |
|||
type = new infer.Arr(inner.type); |
|||
} else if (str.charAt(pos) == "{") { |
|||
var fields = parseLabelList(scope, str, pos + 1, "}"); |
|||
if (!fields) return null; |
|||
type = new infer.Obj(true); |
|||
for (var i = 0; i < fields.types.length; ++i) { |
|||
var field = type.defProp(fields.labels[i]); |
|||
field.initializer = true; |
|||
fields.types[i].propagate(field); |
|||
} |
|||
pos = fields.end; |
|||
madeUp = fields.madeUp; |
|||
} else if (str.charAt(pos) == "(") { |
|||
var inner = parseType(scope, str, pos + 1); |
|||
if (!inner) return null; |
|||
pos = skipSpace(str, inner.end); |
|||
if (str.charAt(pos) != ")") return null; |
|||
++pos; |
|||
type = inner.type; |
|||
} else { |
|||
var start = pos; |
|||
if (!acorn.isIdentifierStart(str.charCodeAt(pos))) return null; |
|||
while (acorn.isIdentifierChar(str.charCodeAt(pos))) ++pos; |
|||
if (start == pos) return null; |
|||
var word = str.slice(start, pos); |
|||
if (/^(number|integer)$/i.test(word)) type = infer.cx().num; |
|||
else if (/^bool(ean)?$/i.test(word)) type = infer.cx().bool; |
|||
else if (/^string$/i.test(word)) type = infer.cx().str; |
|||
else if (/^(null|undefined)$/i.test(word)) type = infer.ANull; |
|||
else if (/^array$/i.test(word)) { |
|||
var inner = null; |
|||
if (str.charAt(pos) == "." && str.charAt(pos + 1) == "<") { |
|||
var inAngles = parseType(scope, str, pos + 2); |
|||
if (!inAngles) return null; |
|||
pos = skipSpace(str, inAngles.end); |
|||
madeUp = inAngles.madeUp; |
|||
if (str.charAt(pos++) != ">") return null; |
|||
inner = inAngles.type; |
|||
} |
|||
type = new infer.Arr(inner); |
|||
} else if (/^object$/i.test(word)) { |
|||
type = new infer.Obj(true); |
|||
if (str.charAt(pos) == "." && str.charAt(pos + 1) == "<") { |
|||
var key = parseType(scope, str, pos + 2); |
|||
if (!key) return null; |
|||
pos = skipSpace(str, key.end); |
|||
madeUp = madeUp || key.madeUp; |
|||
if (str.charAt(pos++) != ",") return null; |
|||
var val = parseType(scope, str, pos); |
|||
if (!val) return null; |
|||
pos = skipSpace(str, val.end); |
|||
madeUp = key.madeUp || val.madeUp; |
|||
if (str.charAt(pos++) != ">") return null; |
|||
val.type.propagate(type.defProp("<i>")); |
|||
} |
|||
} else { |
|||
while (str.charCodeAt(pos) == 46 || |
|||
acorn.isIdentifierChar(str.charCodeAt(pos))) ++pos; |
|||
var path = str.slice(start, pos); |
|||
var cx = infer.cx(), defs = cx.parent && cx.parent.jsdocTypedefs, found; |
|||
if (defs && (path in defs)) { |
|||
type = defs[path]; |
|||
} else if (found = infer.def.parsePath(path, scope).getObjType()) { |
|||
type = maybeInstance(found, path); |
|||
} else { |
|||
if (!cx.jsdocPlaceholders) cx.jsdocPlaceholders = Object.create(null); |
|||
if (!(path in cx.jsdocPlaceholders)) |
|||
type = cx.jsdocPlaceholders[path] = new infer.Obj(null, path); |
|||
else |
|||
type = cx.jsdocPlaceholders[path]; |
|||
madeUp = true; |
|||
} |
|||
} |
|||
} |
|||
|
|||
return {type: type, end: pos, madeUp: madeUp}; |
|||
} |
|||
|
|||
function maybeInstance(type, path) { |
|||
if (type instanceof infer.Fn && /^[A-Z]/.test(path)) { |
|||
var proto = type.getProp("prototype").getObjType(); |
|||
if (proto instanceof infer.Obj) return infer.getInstance(proto); |
|||
} |
|||
return type; |
|||
} |
|||
|
|||
function parseTypeOuter(scope, str, pos) { |
|||
pos = skipSpace(str, pos || 0); |
|||
if (str.charAt(pos) != "{") return null; |
|||
var result = parseType(scope, str, pos + 1); |
|||
if (!result) return null; |
|||
var end = skipSpace(str, result.end); |
|||
if (str.charAt(end) != "}") return null; |
|||
result.end = end + 1; |
|||
return result; |
|||
} |
|||
|
|||
function jsdocInterpretComments(node, scope, aval, comments) { |
|||
var type, args, ret, foundOne, self, parsed; |
|||
|
|||
for (var i = 0; i < comments.length; ++i) { |
|||
var comment = comments[i]; |
|||
var decl = /(?:\n|$|\*)\s*@(type|param|arg(?:ument)?|returns?|this)\s+(.*)/g, m; |
|||
while (m = decl.exec(comment)) { |
|||
if (m[1] == "this" && (parsed = parseType(scope, m[2], 0))) { |
|||
self = parsed; |
|||
foundOne = true; |
|||
continue; |
|||
} |
|||
|
|||
if (!(parsed = parseTypeOuter(scope, m[2]))) continue; |
|||
foundOne = true; |
|||
|
|||
switch(m[1]) { |
|||
case "returns": case "return": |
|||
ret = parsed; break; |
|||
case "type": |
|||
type = parsed; break; |
|||
case "param": case "arg": case "argument": |
|||
var name = m[2].slice(parsed.end).match(/^\s*(\[?)\s*([^\]\s=]+)\s*(?:=[^\]]+\s*)?(\]?).*/); |
|||
if (!name) continue; |
|||
var argname = name[2] + (parsed.isOptional || (name[1] === '[' && name[3] === ']') ? "?" : ""); |
|||
(args || (args = Object.create(null)))[argname] = parsed; |
|||
break; |
|||
} |
|||
} |
|||
} |
|||
|
|||
if (foundOne) applyType(type, self, args, ret, node, aval); |
|||
}; |
|||
|
|||
function jsdocParseTypedefs(text, scope) { |
|||
var cx = infer.cx(); |
|||
|
|||
var re = /\s@typedef\s+(.*)/g, m; |
|||
while (m = re.exec(text)) { |
|||
var parsed = parseTypeOuter(scope, m[1]); |
|||
var name = parsed && m[1].slice(parsed.end).match(/^\s*(\S+)/); |
|||
if (name) |
|||
cx.parent.jsdocTypedefs[name[1]] = parsed.type; |
|||
} |
|||
} |
|||
|
|||
function propagateWithWeight(type, target) { |
|||
var weight = infer.cx().parent._docComment.weight; |
|||
type.type.propagate(target, weight || (type.madeUp ? WG_MADEUP : undefined)); |
|||
} |
|||
|
|||
function applyType(type, self, args, ret, node, aval) { |
|||
var fn; |
|||
if (node.type == "VariableDeclaration") { |
|||
var decl = node.declarations[0]; |
|||
if (decl.init && decl.init.type == "FunctionExpression") fn = decl.init.body.scope.fnType; |
|||
} else if (node.type == "FunctionDeclaration") { |
|||
fn = node.body.scope.fnType; |
|||
} else if (node.type == "AssignmentExpression") { |
|||
if (node.right.type == "FunctionExpression") |
|||
fn = node.right.body.scope.fnType; |
|||
} else if (node.type == "CallExpression") { |
|||
} else { // An object property
|
|||
if (node.value.type == "FunctionExpression") fn = node.value.body.scope.fnType; |
|||
} |
|||
|
|||
if (fn && (args || ret || self)) { |
|||
if (args) for (var i = 0; i < fn.argNames.length; ++i) { |
|||
var name = fn.argNames[i], known = args[name]; |
|||
if (!known && (known = args[name + "?"])) |
|||
fn.argNames[i] += "?"; |
|||
if (known) propagateWithWeight(known, fn.args[i]); |
|||
} |
|||
if (ret) propagateWithWeight(ret, fn.retval); |
|||
if (self) propagateWithWeight(self, fn.self); |
|||
} else if (type) { |
|||
propagateWithWeight(type, aval); |
|||
} |
|||
}; |
|||
}); |
|||
@ -0,0 +1,969 @@ |
|||
function ecma5Spec() |
|||
{ |
|||
return { |
|||
"!name": "ecma5", |
|||
"!define": {"Error.prototype": "Error.prototype"}, |
|||
"Infinity": { |
|||
"!type": "number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Infinity", |
|||
"!doc": "A numeric value representing infinity." |
|||
}, |
|||
"undefined": { |
|||
"!type": "?", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/undefined", |
|||
"!doc": "The value undefined." |
|||
}, |
|||
"NaN": { |
|||
"!type": "number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/NaN", |
|||
"!doc": "A value representing Not-A-Number." |
|||
}, |
|||
"Object": { |
|||
"!type": "fn()", |
|||
"getPrototypeOf": { |
|||
"!type": "fn(obj: ?) -> ?", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/getPrototypeOf", |
|||
"!doc": "Returns the prototype (i.e. the internal prototype) of the specified object." |
|||
}, |
|||
"create": { |
|||
"!type": "fn(proto: ?) -> !custom:Object_create", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/create", |
|||
"!doc": "Creates a new object with the specified prototype object and properties." |
|||
}, |
|||
"defineProperty": { |
|||
"!type": "fn(obj: ?, prop: string, desc: ?) -> !custom:Object_defineProperty", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/defineProperty", |
|||
"!doc": "Defines a new property directly on an object, or modifies an existing property on an object, and returns the object. If you want to see how to use the Object.defineProperty method with a binary-flags-like syntax, see this article." |
|||
}, |
|||
"defineProperties": { |
|||
"!type": "fn(obj: ?, props: ?)", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/defineProperty", |
|||
"!doc": "Defines a new property directly on an object, or modifies an existing property on an object, and returns the object. If you want to see how to use the Object.defineProperty method with a binary-flags-like syntax, see this article." |
|||
}, |
|||
"getOwnPropertyDescriptor": { |
|||
"!type": "fn(obj: ?, prop: string) -> ?", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor", |
|||
"!doc": "Returns a property descriptor for an own property (that is, one directly present on an object, not present by dint of being along an object's prototype chain) of a given object." |
|||
}, |
|||
"keys": { |
|||
"!type": "fn(obj: ?) -> [string]", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/keys", |
|||
"!doc": "Returns an array of a given object's own enumerable properties, in the same order as that provided by a for-in loop (the difference being that a for-in loop enumerates properties in the prototype chain as well)." |
|||
}, |
|||
"getOwnPropertyNames": { |
|||
"!type": "fn(obj: ?) -> [string]", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames", |
|||
"!doc": "Returns an array of all properties (enumerable or not) found directly upon a given object." |
|||
}, |
|||
"seal": { |
|||
"!type": "fn(obj: ?)", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/seal", |
|||
"!doc": "Seals an object, preventing new properties from being added to it and marking all existing properties as non-configurable. Values of present properties can still be changed as long as they are writable." |
|||
}, |
|||
"isSealed": { |
|||
"!type": "fn(obj: ?) -> bool", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/isSealed", |
|||
"!doc": "Determine if an object is sealed." |
|||
}, |
|||
"freeze": { |
|||
"!type": "fn(obj: ?)", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/freeze", |
|||
"!doc": "Freezes an object: that is, prevents new properties from being added to it; prevents existing properties from being removed; and prevents existing properties, or their enumerability, configurability, or writability, from being changed. In essence the object is made effectively immutable. The method returns the object being frozen." |
|||
}, |
|||
"isFrozen": { |
|||
"!type": "fn(obj: ?) -> bool", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/isFrozen", |
|||
"!doc": "Determine if an object is frozen." |
|||
}, |
|||
"preventExtensions": { |
|||
"!type": "fn(obj: ?)", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/preventExtensions", |
|||
"!doc": "Prevents new properties from ever being added to an object." |
|||
}, |
|||
"isExtensible": { |
|||
"!type": "fn(obj: ?) -> bool", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isExtensible", |
|||
"!doc": "The Object.isExtensible() method determines if an object is extensible (whether it can have new properties added to it)." |
|||
}, |
|||
"prototype": { |
|||
"!stdProto": "Object", |
|||
"toString": { |
|||
"!type": "fn() -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/toString", |
|||
"!doc": "Returns a string representing the object." |
|||
}, |
|||
"toLocaleString": { |
|||
"!type": "fn() -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/toLocaleString", |
|||
"!doc": "Returns a string representing the object. This method is meant to be overriden by derived objects for locale-specific purposes." |
|||
}, |
|||
"valueOf": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/valueOf", |
|||
"!doc": "Returns the primitive value of the specified object" |
|||
}, |
|||
"hasOwnProperty": { |
|||
"!type": "fn(prop: string) -> bool", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/hasOwnProperty", |
|||
"!doc": "Returns a boolean indicating whether the object has the specified property." |
|||
}, |
|||
"propertyIsEnumerable": { |
|||
"!type": "fn(prop: string) -> bool", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/propertyIsEnumerable", |
|||
"!doc": "Returns a Boolean indicating whether the specified property is enumerable." |
|||
}, |
|||
"isPrototypeOf": { |
|||
"!type": "fn(obj: ?) -> bool", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isPrototypeOf", |
|||
"!doc": "Tests for an object in another object's prototype chain." |
|||
} |
|||
}, |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object", |
|||
"!doc": "Creates an object wrapper." |
|||
}, |
|||
"Function": { |
|||
"!type": "fn(body: string) -> fn()", |
|||
"prototype": { |
|||
"!stdProto": "Function", |
|||
"apply": { |
|||
"!type": "fn(this: ?, args: [?])", |
|||
"!effects": [ |
|||
"call and return !this this=!0 !1.<i> !1.<i> !1.<i>" |
|||
], |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Function/apply", |
|||
"!doc": "Calls a function with a given this value and arguments provided as an array (or an array like object)." |
|||
}, |
|||
"call": { |
|||
"!type": "fn(this: ?, args?: ?) -> !this.!ret", |
|||
"!effects": [ |
|||
"call and return !this this=!0 !1 !2 !3 !4" |
|||
], |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Function/call", |
|||
"!doc": "Calls a function with a given this value and arguments provided individually." |
|||
}, |
|||
"bind": { |
|||
"!type": "fn(this: ?, args?: ?) -> !custom:Function_bind", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Function/bind", |
|||
"!doc": "Creates a new function that, when called, has its this keyword set to the provided value, with a given sequence of arguments preceding any provided when the new function was called." |
|||
}, |
|||
"prototype": "?" |
|||
}, |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Function", |
|||
"!doc": "Every function in JavaScript is actually a Function object." |
|||
}, |
|||
"Array": { |
|||
"!type": "fn(size: number) -> !custom:Array_ctor", |
|||
"isArray": { |
|||
"!type": "fn(value: ?) -> bool", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/isArray", |
|||
"!doc": "Returns true if an object is an array, false if it is not." |
|||
}, |
|||
"prototype": { |
|||
"!stdProto": "Array", |
|||
"length": { |
|||
"!type": "number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/length", |
|||
"!doc": "An unsigned, 32-bit integer that specifies the number of elements in an array." |
|||
}, |
|||
"concat": { |
|||
"!type": "fn(other: [?]) -> !this", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/concat", |
|||
"!doc": "Returns a new array comprised of this array joined with other array(s) and/or value(s)." |
|||
}, |
|||
"join": { |
|||
"!type": "fn(separator?: string) -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/join", |
|||
"!doc": "Joins all elements of an array into a string." |
|||
}, |
|||
"splice": { |
|||
"!type": "fn(pos: number, amount: number)", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/splice", |
|||
"!doc": "Changes the content of an array, adding new elements while removing old elements." |
|||
}, |
|||
"pop": { |
|||
"!type": "fn() -> !this.<i>", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/pop", |
|||
"!doc": "Removes the last element from an array and returns that element." |
|||
}, |
|||
"push": { |
|||
"!type": "fn(newelt: ?) -> number", |
|||
"!effects": [ |
|||
"propagate !0 !this.<i>" |
|||
], |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/push", |
|||
"!doc": "Mutates an array by appending the given elements and returning the new length of the array." |
|||
}, |
|||
"shift": { |
|||
"!type": "fn() -> !this.<i>", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/shift", |
|||
"!doc": "Removes the first element from an array and returns that element. This method changes the length of the array." |
|||
}, |
|||
"unshift": { |
|||
"!type": "fn(newelt: ?) -> number", |
|||
"!effects": [ |
|||
"propagate !0 !this.<i>" |
|||
], |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/unshift", |
|||
"!doc": "Adds one or more elements to the beginning of an array and returns the new length of the array." |
|||
}, |
|||
"slice": { |
|||
"!type": "fn(from: number, to?: number) -> !this", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/slice", |
|||
"!doc": "Returns a shallow copy of a portion of an array." |
|||
}, |
|||
"reverse": { |
|||
"!type": "fn()", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/reverse", |
|||
"!doc": "Reverses an array in place. The first array element becomes the last and the last becomes the first." |
|||
}, |
|||
"sort": { |
|||
"!type": "fn(compare?: fn(a: ?, b: ?) -> number)", |
|||
"!effects": [ |
|||
"call !0 !this.<i> !this.<i>" |
|||
], |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/sort", |
|||
"!doc": "Sorts the elements of an array in place and returns the array." |
|||
}, |
|||
"indexOf": { |
|||
"!type": "fn(elt: ?, from?: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/indexOf", |
|||
"!doc": "Returns the first index at which a given element can be found in the array, or -1 if it is not present." |
|||
}, |
|||
"lastIndexOf": { |
|||
"!type": "fn(elt: ?, from?: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/lastIndexOf", |
|||
"!doc": "Returns the last index at which a given element can be found in the array, or -1 if it is not present. The array is searched backwards, starting at fromIndex." |
|||
}, |
|||
"every": { |
|||
"!type": "fn(test: fn(elt: ?, i: number) -> bool, context?: ?) -> bool", |
|||
"!effects": [ |
|||
"call !0 this=!1 !this.<i> number" |
|||
], |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/every", |
|||
"!doc": "Tests whether all elements in the array pass the test implemented by the provided function." |
|||
}, |
|||
"some": { |
|||
"!type": "fn(test: fn(elt: ?, i: number) -> bool, context?: ?) -> bool", |
|||
"!effects": [ |
|||
"call !0 this=!1 !this.<i> number" |
|||
], |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/some", |
|||
"!doc": "Tests whether some element in the array passes the test implemented by the provided function." |
|||
}, |
|||
"filter": { |
|||
"!type": "fn(test: fn(elt: ?, i: number) -> bool, context?: ?) -> !this", |
|||
"!effects": [ |
|||
"call !0 this=!1 !this.<i> number" |
|||
], |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/filter", |
|||
"!doc": "Creates a new array with all elements that pass the test implemented by the provided function." |
|||
}, |
|||
"forEach": { |
|||
"!type": "fn(f: fn(elt: ?, i: number), context?: ?)", |
|||
"!effects": [ |
|||
"call !0 this=!1 !this.<i> number" |
|||
], |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/forEach", |
|||
"!doc": "Executes a provided function once per array element." |
|||
}, |
|||
"map": { |
|||
"!type": "fn(f: fn(elt: ?, i: number) -> ?, context?: ?) -> [!0.!ret]", |
|||
"!effects": [ |
|||
"call !0 this=!1 !this.<i> number" |
|||
], |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/map", |
|||
"!doc": "Creates a new array with the results of calling a provided function on every element in this array." |
|||
}, |
|||
"reduce": { |
|||
"!type": "fn(combine: fn(sum: ?, elt: ?, i: number) -> ?, init?: ?) -> !0.!ret", |
|||
"!effects": [ |
|||
"call !0 !1 !this.<i> number" |
|||
], |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/Reduce", |
|||
"!doc": "Apply a function against an accumulator and each value of the array (from left-to-right) as to reduce it to a single value." |
|||
}, |
|||
"reduceRight": { |
|||
"!type": "fn(combine: fn(sum: ?, elt: ?, i: number) -> ?, init?: ?) -> !0.!ret", |
|||
"!effects": [ |
|||
"call !0 !1 !this.<i> number" |
|||
], |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/ReduceRight", |
|||
"!doc": "Apply a function simultaneously against two values of the array (from right-to-left) as to reduce it to a single value." |
|||
} |
|||
}, |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array", |
|||
"!doc": "The JavaScript Array global object is a constructor for arrays, which are high-level, list-like objects." |
|||
}, |
|||
"String": { |
|||
"!type": "fn(value: ?) -> string", |
|||
"fromCharCode": { |
|||
"!type": "fn(code: number) -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/fromCharCode", |
|||
"!doc": "Returns a string created by using the specified sequence of Unicode values." |
|||
}, |
|||
"prototype": { |
|||
"!stdProto": "String", |
|||
"length": { |
|||
"!type": "number", |
|||
"!url": "https://developer.mozilla.org/en/docs/JavaScript/Reference/Global_Objects/String/length", |
|||
"!doc": "Represents the length of a string." |
|||
}, |
|||
"<i>": "string", |
|||
"charAt": { |
|||
"!type": "fn(i: number) -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/charAt", |
|||
"!doc": "Returns the specified character from a string." |
|||
}, |
|||
"charCodeAt": { |
|||
"!type": "fn(i: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/charCodeAt", |
|||
"!doc": "Returns the numeric Unicode value of the character at the given index (except for unicode codepoints > 0x10000)." |
|||
}, |
|||
"indexOf": { |
|||
"!type": "fn(char: string, from?: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/indexOf", |
|||
"!doc": "Returns the index within the calling String object of the first occurrence of the specified value, starting the search at fromIndex,\nreturns -1 if the value is not found." |
|||
}, |
|||
"lastIndexOf": { |
|||
"!type": "fn(char: string, from?: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/lastIndexOf", |
|||
"!doc": "Returns the index within the calling String object of the last occurrence of the specified value, or -1 if not found. The calling string is searched backward, starting at fromIndex." |
|||
}, |
|||
"substring": { |
|||
"!type": "fn(from: number, to?: number) -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/substring", |
|||
"!doc": "Returns a subset of a string between one index and another, or through the end of the string." |
|||
}, |
|||
"substr": { |
|||
"!type": "fn(from: number, length?: number) -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/substr", |
|||
"!doc": "Returns the characters in a string beginning at the specified location through the specified number of characters." |
|||
}, |
|||
"slice": { |
|||
"!type": "fn(from: number, to?: number) -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/slice", |
|||
"!doc": "Extracts a section of a string and returns a new string." |
|||
}, |
|||
"trim": { |
|||
"!type": "fn() -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/Trim", |
|||
"!doc": "Removes whitespace from both ends of the string." |
|||
}, |
|||
"toUpperCase": { |
|||
"!type": "fn() -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/toUpperCase", |
|||
"!doc": "Returns the calling string value converted to uppercase." |
|||
}, |
|||
"toLowerCase": { |
|||
"!type": "fn() -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/toLowerCase", |
|||
"!doc": "Returns the calling string value converted to lowercase." |
|||
}, |
|||
"toLocaleUpperCase": { |
|||
"!type": "fn() -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase", |
|||
"!doc": "Returns the calling string value converted to upper case, according to any locale-specific case mappings." |
|||
}, |
|||
"toLocaleLowerCase": { |
|||
"!type": "fn() -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase", |
|||
"!doc": "Returns the calling string value converted to lower case, according to any locale-specific case mappings." |
|||
}, |
|||
"split": { |
|||
"!type": "fn(pattern: string) -> [string]", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/split", |
|||
"!doc": "Splits a String object into an array of strings by separating the string into substrings." |
|||
}, |
|||
"concat": { |
|||
"!type": "fn(other: string) -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/concat", |
|||
"!doc": "Combines the text of two or more strings and returns a new string." |
|||
}, |
|||
"localeCompare": { |
|||
"!type": "fn(other: string) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/localeCompare", |
|||
"!doc": "Returns a number indicating whether a reference string comes before or after or is the same as the given string in sort order." |
|||
}, |
|||
"match": { |
|||
"!type": "fn(pattern: +RegExp) -> [string]", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/match", |
|||
"!doc": "Used to retrieve the matches when matching a string against a regular expression." |
|||
}, |
|||
"replace": { |
|||
"!type": "fn(pattern: +RegExp, replacement: string) -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/replace", |
|||
"!doc": "Returns a new string with some or all matches of a pattern replaced by a replacement. The pattern can be a string or a RegExp, and the replacement can be a string or a function to be called for each match." |
|||
}, |
|||
"search": { |
|||
"!type": "fn(pattern: +RegExp) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/search", |
|||
"!doc": "Executes the search for a match between a regular expression and this String object." |
|||
} |
|||
}, |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String", |
|||
"!doc": "The String global object is a constructor for strings, or a sequence of characters." |
|||
}, |
|||
"Number": { |
|||
"!type": "fn(value: ?) -> number", |
|||
"MAX_VALUE": { |
|||
"!type": "number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Number/MAX_VALUE", |
|||
"!doc": "The maximum numeric value representable in JavaScript." |
|||
}, |
|||
"MIN_VALUE": { |
|||
"!type": "number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Number/MIN_VALUE", |
|||
"!doc": "The smallest positive numeric value representable in JavaScript." |
|||
}, |
|||
"POSITIVE_INFINITY": { |
|||
"!type": "number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY", |
|||
"!doc": "A value representing the positive Infinity value." |
|||
}, |
|||
"NEGATIVE_INFINITY": { |
|||
"!type": "number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY", |
|||
"!doc": "A value representing the negative Infinity value." |
|||
}, |
|||
"prototype": { |
|||
"!stdProto": "Number", |
|||
"toString": { |
|||
"!type": "fn(radix?: number) -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Number/toString", |
|||
"!doc": "Returns a string representing the specified Number object" |
|||
}, |
|||
"toFixed": { |
|||
"!type": "fn(digits: number) -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Number/toFixed", |
|||
"!doc": "Formats a number using fixed-point notation" |
|||
}, |
|||
"toExponential": { |
|||
"!type": "fn(digits: number) -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Number/toExponential", |
|||
"!doc": "Returns a string representing the Number object in exponential notation" |
|||
}, |
|||
"toPrecision": { |
|||
"!type": "fn(digits: number) -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Number/toPrecision", |
|||
"!doc": "The toPrecision() method returns a string representing the number to the specified precision." |
|||
} |
|||
}, |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Number", |
|||
"!doc": "The Number JavaScript object is a wrapper object allowing you to work with numerical values. A Number object is created using the Number() constructor." |
|||
}, |
|||
"Boolean": { |
|||
"!type": "fn(value: ?) -> bool", |
|||
"prototype": { |
|||
"!stdProto": "Boolean" |
|||
}, |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Boolean", |
|||
"!doc": "The Boolean object is an object wrapper for a boolean value." |
|||
}, |
|||
"RegExp": { |
|||
"!type": "fn(source: string, flags?: string)", |
|||
"prototype": { |
|||
"!stdProto": "RegExp", |
|||
"exec": { |
|||
"!type": "fn(input: string) -> [string]", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp/exec", |
|||
"!doc": "Executes a search for a match in a specified string. Returns a result array, or null." |
|||
}, |
|||
"test": { |
|||
"!type": "fn(input: string) -> bool", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp/test", |
|||
"!doc": "Executes the search for a match between a regular expression and a specified string. Returns true or false." |
|||
}, |
|||
"global": { |
|||
"!type": "bool", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp", |
|||
"!doc": "Creates a regular expression object for matching text with a pattern." |
|||
}, |
|||
"ignoreCase": { |
|||
"!type": "bool", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp", |
|||
"!doc": "Creates a regular expression object for matching text with a pattern." |
|||
}, |
|||
"multiline": { |
|||
"!type": "bool", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp/multiline", |
|||
"!doc": "Reflects whether or not to search in strings across multiple lines.\n" |
|||
}, |
|||
"source": { |
|||
"!type": "string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp/source", |
|||
"!doc": "A read-only property that contains the text of the pattern, excluding the forward slashes.\n" |
|||
}, |
|||
"lastIndex": { |
|||
"!type": "number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp/lastIndex", |
|||
"!doc": "A read/write integer property that specifies the index at which to start the next match." |
|||
} |
|||
}, |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp", |
|||
"!doc": "Creates a regular expression object for matching text with a pattern." |
|||
}, |
|||
"Date": { |
|||
"!type": "fn(ms: number)", |
|||
"parse": { |
|||
"!type": "fn(source: string) -> +Date", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/parse", |
|||
"!doc": "Parses a string representation of a date, and returns the number of milliseconds since January 1, 1970, 00:00:00 UTC." |
|||
}, |
|||
"UTC": { |
|||
"!type": "fn(year: number, month: number, date: number, hour?: number, min?: number, sec?: number, ms?: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/UTC", |
|||
"!doc": "Accepts the same parameters as the longest form of the constructor, and returns the number of milliseconds in a Date object since January 1, 1970, 00:00:00, universal time." |
|||
}, |
|||
"now": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/now", |
|||
"!doc": "Returns the number of milliseconds elapsed since 1 January 1970 00:00:00 UTC." |
|||
}, |
|||
"prototype": { |
|||
"toUTCString": { |
|||
"!type": "fn() -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/toUTCString", |
|||
"!doc": "Converts a date to a string, using the universal time convention." |
|||
}, |
|||
"toISOString": { |
|||
"!type": "fn() -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/toISOString", |
|||
"!doc": "JavaScript provides a direct way to convert a date object into a string in ISO format, the ISO 8601 Extended Format." |
|||
}, |
|||
"toDateString": { |
|||
"!type": "fn() -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/toDateString", |
|||
"!doc": "Returns the date portion of a Date object in human readable form in American English." |
|||
}, |
|||
"toTimeString": { |
|||
"!type": "fn() -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/toTimeString", |
|||
"!doc": "Returns the time portion of a Date object in human readable form in American English." |
|||
}, |
|||
"toLocaleDateString": { |
|||
"!type": "fn() -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/toLocaleDateString", |
|||
"!doc": "Converts a date to a string, returning the \"date\" portion using the operating system's locale's conventions.\n" |
|||
}, |
|||
"toLocaleTimeString": { |
|||
"!type": "fn() -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString", |
|||
"!doc": "Converts a date to a string, returning the \"time\" portion using the current locale's conventions." |
|||
}, |
|||
"getTime": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/getTime", |
|||
"!doc": "Returns the numeric value corresponding to the time for the specified date according to universal time." |
|||
}, |
|||
"getFullYear": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/getFullYear", |
|||
"!doc": "Returns the year of the specified date according to local time." |
|||
}, |
|||
"getYear": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/getYear", |
|||
"!doc": "Returns the year in the specified date according to local time." |
|||
}, |
|||
"getMonth": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/getMonth", |
|||
"!doc": "Returns the month in the specified date according to local time." |
|||
}, |
|||
"getUTCMonth": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/getUTCMonth", |
|||
"!doc": "Returns the month of the specified date according to universal time.\n" |
|||
}, |
|||
"getDate": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/getDate", |
|||
"!doc": "Returns the day of the month for the specified date according to local time." |
|||
}, |
|||
"getUTCDate": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/getUTCDate", |
|||
"!doc": "Returns the day (date) of the month in the specified date according to universal time.\n" |
|||
}, |
|||
"getDay": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/getDay", |
|||
"!doc": "Returns the day of the week for the specified date according to local time." |
|||
}, |
|||
"getUTCDay": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/getUTCDay", |
|||
"!doc": "Returns the day of the week in the specified date according to universal time.\n" |
|||
}, |
|||
"getHours": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/getHours", |
|||
"!doc": "Returns the hour for the specified date according to local time." |
|||
}, |
|||
"getUTCHours": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/getUTCHours", |
|||
"!doc": "Returns the hours in the specified date according to universal time.\n" |
|||
}, |
|||
"getMinutes": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/getMinutes", |
|||
"!doc": "Returns the minutes in the specified date according to local time." |
|||
}, |
|||
"getUTCMinutes": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date", |
|||
"!doc": "Creates JavaScript Date instances which let you work with dates and times." |
|||
}, |
|||
"getSeconds": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/getSeconds", |
|||
"!doc": "Returns the seconds in the specified date according to local time." |
|||
}, |
|||
"getUTCSeconds": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/getUTCSeconds", |
|||
"!doc": "Returns the seconds in the specified date according to universal time.\n" |
|||
}, |
|||
"getMilliseconds": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/getMilliseconds", |
|||
"!doc": "Returns the milliseconds in the specified date according to local time." |
|||
}, |
|||
"getUTCMilliseconds": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/getUTCMilliseconds", |
|||
"!doc": "Returns the milliseconds in the specified date according to universal time.\n" |
|||
}, |
|||
"getTimezoneOffset": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset", |
|||
"!doc": "Returns the time-zone offset from UTC, in minutes, for the current locale." |
|||
}, |
|||
"setTime": { |
|||
"!type": "fn(date: +Date) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/setTime", |
|||
"!doc": "Sets the Date object to the time represented by a number of milliseconds since January 1, 1970, 00:00:00 UTC.\n" |
|||
}, |
|||
"setFullYear": { |
|||
"!type": "fn(year: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/setFullYear", |
|||
"!doc": "Sets the full year for a specified date according to local time.\n" |
|||
}, |
|||
"setUTCFullYear": { |
|||
"!type": "fn(year: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/setUTCFullYear", |
|||
"!doc": "Sets the full year for a specified date according to universal time.\n" |
|||
}, |
|||
"setMonth": { |
|||
"!type": "fn(month: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/setMonth", |
|||
"!doc": "Set the month for a specified date according to local time." |
|||
}, |
|||
"setUTCMonth": { |
|||
"!type": "fn(month: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/setUTCMonth", |
|||
"!doc": "Sets the month for a specified date according to universal time.\n" |
|||
}, |
|||
"setDate": { |
|||
"!type": "fn(day: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/setDate", |
|||
"!doc": "Sets the day of the month for a specified date according to local time." |
|||
}, |
|||
"setUTCDate": { |
|||
"!type": "fn(day: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/setUTCDate", |
|||
"!doc": "Sets the day of the month for a specified date according to universal time.\n" |
|||
}, |
|||
"setHours": { |
|||
"!type": "fn(hour: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/setHours", |
|||
"!doc": "Sets the hours for a specified date according to local time, and returns the number of milliseconds since 1 January 1970 00:00:00 UTC until the time represented by the updated Date instance." |
|||
}, |
|||
"setUTCHours": { |
|||
"!type": "fn(hour: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/setUTCHours", |
|||
"!doc": "Sets the hour for a specified date according to universal time.\n" |
|||
}, |
|||
"setMinutes": { |
|||
"!type": "fn(min: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/setMinutes", |
|||
"!doc": "Sets the minutes for a specified date according to local time." |
|||
}, |
|||
"setUTCMinutes": { |
|||
"!type": "fn(min: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/setUTCMinutes", |
|||
"!doc": "Sets the minutes for a specified date according to universal time.\n" |
|||
}, |
|||
"setSeconds": { |
|||
"!type": "fn(sec: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/setSeconds", |
|||
"!doc": "Sets the seconds for a specified date according to local time." |
|||
}, |
|||
"setUTCSeconds": { |
|||
"!type": "fn(sec: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/setUTCSeconds", |
|||
"!doc": "Sets the seconds for a specified date according to universal time.\n" |
|||
}, |
|||
"setMilliseconds": { |
|||
"!type": "fn(ms: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/setMilliseconds", |
|||
"!doc": "Sets the milliseconds for a specified date according to local time.\n" |
|||
}, |
|||
"setUTCMilliseconds": { |
|||
"!type": "fn(ms: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/setUTCMilliseconds", |
|||
"!doc": "Sets the milliseconds for a specified date according to universal time.\n" |
|||
} |
|||
}, |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date", |
|||
"!doc": "Creates JavaScript Date instances which let you work with dates and times." |
|||
}, |
|||
"Error": { |
|||
"!type": "fn(message: string)", |
|||
"prototype": { |
|||
"name": { |
|||
"!type": "string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Error/name", |
|||
"!doc": "A name for the type of error." |
|||
}, |
|||
"message": { |
|||
"!type": "string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Error/message", |
|||
"!doc": "A human-readable description of the error." |
|||
} |
|||
}, |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Error", |
|||
"!doc": "Creates an error object." |
|||
}, |
|||
"SyntaxError": { |
|||
"!type": "fn(message: string)", |
|||
"prototype": "Error.prototype", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/SyntaxError", |
|||
"!doc": "Represents an error when trying to interpret syntactically invalid code." |
|||
}, |
|||
"ReferenceError": { |
|||
"!type": "fn(message: string)", |
|||
"prototype": "Error.prototype", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/ReferenceError", |
|||
"!doc": "Represents an error when a non-existent variable is referenced." |
|||
}, |
|||
"URIError": { |
|||
"!type": "fn(message: string)", |
|||
"prototype": "Error.prototype", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/URIError", |
|||
"!doc": "Represents an error when a malformed URI is encountered." |
|||
}, |
|||
"EvalError": { |
|||
"!type": "fn(message: string)", |
|||
"prototype": "Error.prototype", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/EvalError", |
|||
"!doc": "Represents an error regarding the eval function." |
|||
}, |
|||
"RangeError": { |
|||
"!type": "fn(message: string)", |
|||
"prototype": "Error.prototype", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RangeError", |
|||
"!doc": "Represents an error when a number is not within the correct range allowed." |
|||
}, |
|||
"TypeError": { |
|||
"!type": "fn(message: string)", |
|||
"prototype": "Error.prototype", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/TypeError", |
|||
"!doc": "Represents an error an error when a value is not of the expected type." |
|||
}, |
|||
"parseInt": { |
|||
"!type": "fn(string: string, radix?: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/parseInt", |
|||
"!doc": "Parses a string argument and returns an integer of the specified radix or base." |
|||
}, |
|||
"parseFloat": { |
|||
"!type": "fn(string: string) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/parseFloat", |
|||
"!doc": "Parses a string argument and returns a floating point number." |
|||
}, |
|||
"isNaN": { |
|||
"!type": "fn(value: number) -> bool", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/isNaN", |
|||
"!doc": "Determines whether a value is NaN or not. Be careful, this function is broken. You may be interested in ECMAScript 6 Number.isNaN." |
|||
}, |
|||
"isFinite": { |
|||
"!type": "fn(value: number) -> bool", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/isFinite", |
|||
"!doc": "Determines whether the passed value is a finite number." |
|||
}, |
|||
"eval": { |
|||
"!type": "fn(code: string) -> ?", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/eval", |
|||
"!doc": "Evaluates JavaScript code represented as a string." |
|||
}, |
|||
"encodeURI": { |
|||
"!type": "fn(uri: string) -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/encodeURI", |
|||
"!doc": "Encodes a Uniform Resource Identifier (URI) by replacing each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the character (will only be four escape sequences for characters composed of two \"surrogate\" characters)." |
|||
}, |
|||
"encodeURIComponent": { |
|||
"!type": "fn(uri: string) -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/encodeURIComponent", |
|||
"!doc": "Encodes a Uniform Resource Identifier (URI) component by replacing each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the character (will only be four escape sequences for characters composed of two \"surrogate\" characters)." |
|||
}, |
|||
"decodeURI": { |
|||
"!type": "fn(uri: string) -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/decodeURI", |
|||
"!doc": "Decodes a Uniform Resource Identifier (URI) previously created by encodeURI or by a similar routine." |
|||
}, |
|||
"decodeURIComponent": { |
|||
"!type": "fn(uri: string) -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/decodeURIComponent", |
|||
"!doc": "Decodes a Uniform Resource Identifier (URI) component previously created by encodeURIComponent or by a similar routine." |
|||
}, |
|||
"Math": { |
|||
"E": { |
|||
"!type": "number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/E", |
|||
"!doc": "The base of natural logarithms, e, approximately 2.718." |
|||
}, |
|||
"LN2": { |
|||
"!type": "number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/LN2", |
|||
"!doc": "The natural logarithm of 2, approximately 0.693." |
|||
}, |
|||
"LN10": { |
|||
"!type": "number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/LN10", |
|||
"!doc": "The natural logarithm of 10, approximately 2.302." |
|||
}, |
|||
"LOG2E": { |
|||
"!type": "number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/LOG2E", |
|||
"!doc": "The base 2 logarithm of E (approximately 1.442)." |
|||
}, |
|||
"LOG10E": { |
|||
"!type": "number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/LOG10E", |
|||
"!doc": "The base 10 logarithm of E (approximately 0.434)." |
|||
}, |
|||
"SQRT1_2": { |
|||
"!type": "number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/SQRT1_2", |
|||
"!doc": "The square root of 1/2; equivalently, 1 over the square root of 2, approximately 0.707." |
|||
}, |
|||
"SQRT2": { |
|||
"!type": "number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/SQRT2", |
|||
"!doc": "The square root of 2, approximately 1.414." |
|||
}, |
|||
"PI": { |
|||
"!type": "number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/PI", |
|||
"!doc": "The ratio of the circumference of a circle to its diameter, approximately 3.14159." |
|||
}, |
|||
"abs": { |
|||
"!type": "fn(number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/abs", |
|||
"!doc": "Returns the absolute value of a number." |
|||
}, |
|||
"cos": { |
|||
"!type": "fn(number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/cos", |
|||
"!doc": "Returns the cosine of a number." |
|||
}, |
|||
"sin": { |
|||
"!type": "fn(number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/sin", |
|||
"!doc": "Returns the sine of a number." |
|||
}, |
|||
"tan": { |
|||
"!type": "fn(number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/tan", |
|||
"!doc": "Returns the tangent of a number." |
|||
}, |
|||
"acos": { |
|||
"!type": "fn(number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/acos", |
|||
"!doc": "Returns the arccosine (in radians) of a number." |
|||
}, |
|||
"asin": { |
|||
"!type": "fn(number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/asin", |
|||
"!doc": "Returns the arcsine (in radians) of a number." |
|||
}, |
|||
"atan": { |
|||
"!type": "fn(number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/atan", |
|||
"!doc": "Returns the arctangent (in radians) of a number." |
|||
}, |
|||
"atan2": { |
|||
"!type": "fn(y: number, x: number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/atan2", |
|||
"!doc": "Returns the arctangent of the quotient of its arguments." |
|||
}, |
|||
"ceil": { |
|||
"!type": "fn(number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/ceil", |
|||
"!doc": "Returns the smallest integer greater than or equal to a number." |
|||
}, |
|||
"floor": { |
|||
"!type": "fn(number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/floor", |
|||
"!doc": "Returns the largest integer less than or equal to a number." |
|||
}, |
|||
"round": { |
|||
"!type": "fn(number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/round", |
|||
"!doc": "Returns the value of a number rounded to the nearest integer." |
|||
}, |
|||
"exp": { |
|||
"!type": "fn(number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/exp", |
|||
"!doc": "Returns Ex, where x is the argument, and E is Euler's constant, the base of the natural logarithms." |
|||
}, |
|||
"log": { |
|||
"!type": "fn(number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/log", |
|||
"!doc": "Returns the natural logarithm (base E) of a number." |
|||
}, |
|||
"sqrt": { |
|||
"!type": "fn(number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/sqrt", |
|||
"!doc": "Returns the square root of a number." |
|||
}, |
|||
"pow": { |
|||
"!type": "fn(number, number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/pow", |
|||
"!doc": "Returns base to the exponent power, that is, baseexponent." |
|||
}, |
|||
"max": { |
|||
"!type": "fn(number, number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/max", |
|||
"!doc": "Returns the largest of zero or more numbers." |
|||
}, |
|||
"min": { |
|||
"!type": "fn(number, number) -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/min", |
|||
"!doc": "Returns the smallest of zero or more numbers." |
|||
}, |
|||
"random": { |
|||
"!type": "fn() -> number", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/random", |
|||
"!doc": "Returns a floating-point, pseudo-random number in the range [0, 1) that is, from 0 (inclusive) up to but not including 1 (exclusive), which you can then scale to your desired range." |
|||
}, |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math", |
|||
"!doc": "A built-in object that has properties and methods for mathematical constants and functions." |
|||
}, |
|||
"JSON": { |
|||
"parse": { |
|||
"!type": "fn(json: string) -> ?", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/JSON/parse", |
|||
"!doc": "Parse a string as JSON, optionally transforming the value produced by parsing." |
|||
}, |
|||
"stringify": { |
|||
"!type": "fn(value: ?) -> string", |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/JSON/stringify", |
|||
"!doc": "Convert a value to JSON, optionally replacing values if a replacer function is specified, or optionally including only the specified properties if a replacer array is specified." |
|||
}, |
|||
"!url": "https://developer.mozilla.org/en-US/docs/JSON", |
|||
"!doc": "JSON (JavaScript Object Notation) is a data-interchange format. It closely resembles a subset of JavaScript syntax, although it is not a strict subset. (See JSON in the JavaScript Reference for full details.) It is useful when writing any kind of JavaScript-based application, including websites and browser extensions. For example, you might store user information in JSON format in a cookie, or you might store extension preferences in JSON in a string-valued browser preference." |
|||
} |
|||
} |
|||
} |
|||
File diff suppressed because it is too large
@ -0,0 +1,26 @@ |
|||
(function(root, mod) { |
|||
if (typeof exports == "object" && typeof module == "object") // CommonJS
|
|||
return mod(exports); |
|||
if (typeof define == "function" && define.amd) // AMD
|
|||
return define(["exports"], mod); |
|||
mod((root.tern || (root.tern = {})).signal = {}); // Plain browser env
|
|||
})(this, function(exports) { |
|||
function on(type, f) { |
|||
var handlers = this._handlers || (this._handlers = Object.create(null)); |
|||
(handlers[type] || (handlers[type] = [])).push(f); |
|||
} |
|||
function off(type, f) { |
|||
var arr = this._handlers && this._handlers[type]; |
|||
if (arr) for (var i = 0; i < arr.length; ++i) |
|||
if (arr[i] == f) { arr.splice(i, 1); break; } |
|||
} |
|||
function signal(type, a1, a2, a3, a4) { |
|||
var arr = this._handlers && this._handlers[type]; |
|||
if (arr) for (var i = 0; i < arr.length; ++i) arr[i].call(this, a1, a2, a3, a4); |
|||
} |
|||
|
|||
exports.mixin = function(obj) { |
|||
obj.on = on; obj.off = off; obj.signal = signal; |
|||
return obj; |
|||
}; |
|||
}); |
|||
@ -0,0 +1,697 @@ |
|||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
|||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
|||
|
|||
// Glue code between CodeMirror and Tern.
|
|||
//
|
|||
// Create a CodeMirror.TernServer to wrap an actual Tern server,
|
|||
// register open documents (CodeMirror.Doc instances) with it, and
|
|||
// call its methods to activate the assisting functions that Tern
|
|||
// provides.
|
|||
//
|
|||
// Options supported (all optional):
|
|||
// * defs: An array of JSON definition data structures.
|
|||
// * plugins: An object mapping plugin names to configuration
|
|||
// options.
|
|||
// * getFile: A function(name, c) that can be used to access files in
|
|||
// the project that haven't been loaded yet. Simply do c(null) to
|
|||
// indicate that a file is not available.
|
|||
// * fileFilter: A function(value, docName, doc) that will be applied
|
|||
// to documents before passing them on to Tern.
|
|||
// * switchToDoc: A function(name, doc) that should, when providing a
|
|||
// multi-file view, switch the view or focus to the named file.
|
|||
// * showError: A function(editor, message) that can be used to
|
|||
// override the way errors are displayed.
|
|||
// * completionTip: Customize the content in tooltips for completions.
|
|||
// Is passed a single argument—the completion's data as returned by
|
|||
// Tern—and may return a string, DOM node, or null to indicate that
|
|||
// no tip should be shown. By default the docstring is shown.
|
|||
// * typeTip: Like completionTip, but for the tooltips shown for type
|
|||
// queries.
|
|||
// * responseFilter: A function(doc, query, request, error, data) that
|
|||
// will be applied to the Tern responses before treating them
|
|||
//
|
|||
//
|
|||
// It is possible to run the Tern server in a web worker by specifying
|
|||
// these additional options:
|
|||
// * useWorker: Set to true to enable web worker mode. You'll probably
|
|||
// want to feature detect the actual value you use here, for example
|
|||
// !!window.Worker.
|
|||
// * workerScript: The main script of the worker. Point this to
|
|||
// wherever you are hosting worker.js from this directory.
|
|||
// * workerDeps: An array of paths pointing (relative to workerScript)
|
|||
// to the Acorn and Tern libraries and any Tern plugins you want to
|
|||
// load. Or, if you minified those into a single script and included
|
|||
// them in the workerScript, simply leave this undefined.
|
|||
|
|||
(function(mod) { |
|||
if (typeof exports == "object" && typeof module == "object") // CommonJS
|
|||
mod(require("../../lib/codemirror")); |
|||
else if (typeof define == "function" && define.amd) // AMD
|
|||
define(["../../lib/codemirror"], mod); |
|||
else // Plain browser env
|
|||
mod(CodeMirror); |
|||
})(function(CodeMirror) { |
|||
"use strict"; |
|||
// declare global: tern
|
|||
|
|||
CodeMirror.TernServer = function(options) { |
|||
var self = this; |
|||
this.options = options || {}; |
|||
var plugins = this.options.plugins || (this.options.plugins = {}); |
|||
if (!plugins.doc_comment) plugins.doc_comment = true; |
|||
if (this.options.useWorker) { |
|||
this.server = new WorkerServer(this); |
|||
} else { |
|||
this.server = new tern.Server({ |
|||
getFile: function(name, c) { return getFile(self, name, c); }, |
|||
async: true, |
|||
defs: this.options.defs || [], |
|||
plugins: plugins |
|||
}); |
|||
} |
|||
this.docs = Object.create(null); |
|||
this.trackChange = function(doc, change) { trackChange(self, doc, change); }; |
|||
|
|||
this.cachedArgHints = null; |
|||
this.activeArgHints = null; |
|||
this.jumpStack = []; |
|||
|
|||
this.getHint = function(cm, c) { return hint(self, cm, c); }; |
|||
this.getHint.async = true; |
|||
}; |
|||
|
|||
CodeMirror.TernServer.prototype = { |
|||
addDoc: function(name, doc) { |
|||
var data = {doc: doc, name: name, changed: null}; |
|||
this.server.addFile(name, docValue(this, data)); |
|||
CodeMirror.on(doc, "change", this.trackChange); |
|||
return this.docs[name] = data; |
|||
}, |
|||
|
|||
delDoc: function(id) { |
|||
var found = resolveDoc(this, id); |
|||
if (!found) return; |
|||
CodeMirror.off(found.doc, "change", this.trackChange); |
|||
delete this.docs[found.name]; |
|||
this.server.delFile(found.name); |
|||
}, |
|||
|
|||
hideDoc: function(id) { |
|||
closeArgHints(this); |
|||
var found = resolveDoc(this, id); |
|||
if (found && found.changed) sendDoc(this, found); |
|||
}, |
|||
|
|||
complete: function(cm) { |
|||
cm.showHint({hint: this.getHint}); |
|||
}, |
|||
|
|||
showType: function(cm, pos, c) { showContextInfo(this, cm, pos, "type", c); }, |
|||
|
|||
showDocs: function(cm, pos, c) { showContextInfo(this, cm, pos, "documentation", c); }, |
|||
|
|||
updateArgHints: function(cm) { updateArgHints(this, cm); }, |
|||
|
|||
jumpToDef: function(cm) { jumpToDef(this, cm); }, |
|||
|
|||
jumpBack: function(cm) { jumpBack(this, cm); }, |
|||
|
|||
rename: function(cm) { rename(this, cm); }, |
|||
|
|||
selectName: function(cm) { selectName(this, cm); }, |
|||
|
|||
request: function (cm, query, c, pos) { |
|||
var self = this; |
|||
var doc = findDoc(this, cm.getDoc()); |
|||
var request = buildRequest(this, doc, query, pos); |
|||
|
|||
this.server.request(request, function (error, data) { |
|||
if (!error && self.options.responseFilter) |
|||
data = self.options.responseFilter(doc, query, request, error, data); |
|||
c(error, data); |
|||
}); |
|||
}, |
|||
|
|||
destroy: function () { |
|||
if (this.worker) { |
|||
this.worker.terminate(); |
|||
this.worker = null; |
|||
} |
|||
} |
|||
}; |
|||
|
|||
var Pos = CodeMirror.Pos; |
|||
var cls = "CodeMirror-Tern-"; |
|||
var bigDoc = 250; |
|||
|
|||
function getFile(ts, name, c) { |
|||
var buf = ts.docs[name]; |
|||
if (buf) |
|||
c(docValue(ts, buf)); |
|||
else if (ts.options.getFile) |
|||
ts.options.getFile(name, c); |
|||
else |
|||
c(null); |
|||
} |
|||
|
|||
function findDoc(ts, doc, name) { |
|||
for (var n in ts.docs) { |
|||
var cur = ts.docs[n]; |
|||
if (cur.doc == doc) return cur; |
|||
} |
|||
if (!name) for (var i = 0;; ++i) { |
|||
n = "[doc" + (i || "") + "]"; |
|||
if (!ts.docs[n]) { name = n; break; } |
|||
} |
|||
return ts.addDoc(name, doc); |
|||
} |
|||
|
|||
function resolveDoc(ts, id) { |
|||
if (typeof id == "string") return ts.docs[id]; |
|||
if (id instanceof CodeMirror) id = id.getDoc(); |
|||
if (id instanceof CodeMirror.Doc) return findDoc(ts, id); |
|||
} |
|||
|
|||
function trackChange(ts, doc, change) { |
|||
var data = findDoc(ts, doc); |
|||
|
|||
var argHints = ts.cachedArgHints; |
|||
if (argHints && argHints.doc == doc && cmpPos(argHints.start, change.to) <= 0) |
|||
ts.cachedArgHints = null; |
|||
|
|||
var changed = data.changed; |
|||
if (changed == null) |
|||
data.changed = changed = {from: change.from.line, to: change.from.line}; |
|||
var end = change.from.line + (change.text.length - 1); |
|||
if (change.from.line < changed.to) changed.to = changed.to - (change.to.line - end); |
|||
if (end >= changed.to) changed.to = end + 1; |
|||
if (changed.from > change.from.line) changed.from = change.from.line; |
|||
|
|||
if (doc.lineCount() > bigDoc && change.to - changed.from > 100) setTimeout(function() { |
|||
if (data.changed && data.changed.to - data.changed.from > 100) sendDoc(ts, data); |
|||
}, 200); |
|||
} |
|||
|
|||
function sendDoc(ts, doc) { |
|||
ts.server.request({files: [{type: "full", name: doc.name, text: docValue(ts, doc)}]}, function(error) { |
|||
if (error) window.console.error(error); |
|||
else doc.changed = null; |
|||
}); |
|||
} |
|||
|
|||
// Completion
|
|||
|
|||
function hint(ts, cm, c) { |
|||
ts.request(cm, {type: "completions", types: true, docs: true, urls: true}, function(error, data) { |
|||
if (error) return showError(ts, cm, error); |
|||
var completions = [], after = ""; |
|||
var from = data.start, to = data.end; |
|||
if (cm.getRange(Pos(from.line, from.ch - 2), from) == "[\"" && |
|||
cm.getRange(to, Pos(to.line, to.ch + 2)) != "\"]") |
|||
after = "\"]"; |
|||
|
|||
for (var i = 0; i < data.completions.length; ++i) { |
|||
var completion = data.completions[i], className = typeToIcon(completion.type); |
|||
if (data.guess) className += " " + cls + "guess"; |
|||
completions.push({text: completion.name + after, |
|||
displayText: completion.name, |
|||
className: className, |
|||
data: completion}); |
|||
} |
|||
|
|||
var obj = {from: from, to: to, list: completions}; |
|||
var tooltip = null; |
|||
CodeMirror.on(obj, "close", function() { remove(tooltip); }); |
|||
CodeMirror.on(obj, "update", function() { remove(tooltip); }); |
|||
CodeMirror.on(obj, "select", function(cur, node) { |
|||
remove(tooltip); |
|||
var content = ts.options.completionTip ? ts.options.completionTip(cur.data) : cur.data.doc; |
|||
if (content) { |
|||
tooltip = makeTooltip(node.parentNode.getBoundingClientRect().right + window.pageXOffset, |
|||
node.getBoundingClientRect().top + window.pageYOffset, content); |
|||
tooltip.className += " " + cls + "hint-doc"; |
|||
} |
|||
}); |
|||
c(obj); |
|||
}); |
|||
} |
|||
|
|||
function typeToIcon(type) { |
|||
var suffix; |
|||
if (type == "?") suffix = "unknown"; |
|||
else if (type == "number" || type == "string" || type == "bool") suffix = type; |
|||
else if (/^fn\(/.test(type)) suffix = "fn"; |
|||
else if (/^\[/.test(type)) suffix = "array"; |
|||
else suffix = "object"; |
|||
return cls + "completion " + cls + "completion-" + suffix; |
|||
} |
|||
|
|||
// Type queries
|
|||
|
|||
function showContextInfo(ts, cm, pos, queryName, c) { |
|||
ts.request(cm, queryName, function(error, data) { |
|||
if (error) return showError(ts, cm, error); |
|||
if (ts.options.typeTip) { |
|||
var tip = ts.options.typeTip(data); |
|||
} else { |
|||
var tip = elt("span", null, elt("strong", null, data.type || "not found")); |
|||
if (data.doc) |
|||
tip.appendChild(document.createTextNode(" — " + data.doc)); |
|||
if (data.url) { |
|||
tip.appendChild(document.createTextNode(" ")); |
|||
var child = tip.appendChild(elt("a", null, "[docs]")); |
|||
child.href = data.url; |
|||
child.target = "_blank"; |
|||
} |
|||
} |
|||
tempTooltip(cm, tip); |
|||
if (c) c(); |
|||
}, pos); |
|||
} |
|||
|
|||
// Maintaining argument hints
|
|||
|
|||
function updateArgHints(ts, cm) { |
|||
closeArgHints(ts); |
|||
|
|||
if (cm.somethingSelected()) return; |
|||
var state = cm.getTokenAt(cm.getCursor()).state; |
|||
var inner = CodeMirror.innerMode(cm.getMode(), state); |
|||
if (inner.mode.name != "javascript") return; |
|||
var lex = inner.state.lexical; |
|||
if (lex.info != "call") return; |
|||
|
|||
var ch, argPos = lex.pos || 0, tabSize = cm.getOption("tabSize"); |
|||
for (var line = cm.getCursor().line, e = Math.max(0, line - 9), found = false; line >= e; --line) { |
|||
var str = cm.getLine(line), extra = 0; |
|||
for (var pos = 0;;) { |
|||
var tab = str.indexOf("\t", pos); |
|||
if (tab == -1) break; |
|||
extra += tabSize - (tab + extra) % tabSize - 1; |
|||
pos = tab + 1; |
|||
} |
|||
ch = lex.column - extra; |
|||
if (str.charAt(ch) == "(") {found = true; break;} |
|||
} |
|||
if (!found) return; |
|||
|
|||
var start = Pos(line, ch); |
|||
var cache = ts.cachedArgHints; |
|||
if (cache && cache.doc == cm.getDoc() && cmpPos(start, cache.start) == 0) |
|||
return showArgHints(ts, cm, argPos); |
|||
|
|||
ts.request(cm, {type: "type", preferFunction: true, end: start}, function(error, data) { |
|||
if (error || !data.type || !(/^fn\(/).test(data.type)) return; |
|||
ts.cachedArgHints = { |
|||
start: pos, |
|||
type: parseFnType(data.type), |
|||
name: data.exprName || data.name || "fn", |
|||
guess: data.guess, |
|||
doc: cm.getDoc() |
|||
}; |
|||
showArgHints(ts, cm, argPos); |
|||
}); |
|||
} |
|||
|
|||
function showArgHints(ts, cm, pos) { |
|||
closeArgHints(ts); |
|||
|
|||
var cache = ts.cachedArgHints, tp = cache.type; |
|||
var tip = elt("span", cache.guess ? cls + "fhint-guess" : null, |
|||
elt("span", cls + "fname", cache.name), "("); |
|||
for (var i = 0; i < tp.args.length; ++i) { |
|||
if (i) tip.appendChild(document.createTextNode(", ")); |
|||
var arg = tp.args[i]; |
|||
tip.appendChild(elt("span", cls + "farg" + (i == pos ? " " + cls + "farg-current" : ""), arg.name || "?")); |
|||
if (arg.type != "?") { |
|||
tip.appendChild(document.createTextNode(":\u00a0")); |
|||
tip.appendChild(elt("span", cls + "type", arg.type)); |
|||
} |
|||
} |
|||
tip.appendChild(document.createTextNode(tp.rettype ? ") ->\u00a0" : ")")); |
|||
if (tp.rettype) tip.appendChild(elt("span", cls + "type", tp.rettype)); |
|||
var place = cm.cursorCoords(null, "page"); |
|||
ts.activeArgHints = makeTooltip(place.right + 1, place.bottom, tip); |
|||
} |
|||
|
|||
function parseFnType(text) { |
|||
var args = [], pos = 3; |
|||
|
|||
function skipMatching(upto) { |
|||
var depth = 0, start = pos; |
|||
for (;;) { |
|||
var next = text.charAt(pos); |
|||
if (upto.test(next) && !depth) return text.slice(start, pos); |
|||
if (/[{\[\(]/.test(next)) ++depth; |
|||
else if (/[}\]\)]/.test(next)) --depth; |
|||
++pos; |
|||
} |
|||
} |
|||
|
|||
// Parse arguments
|
|||
if (text.charAt(pos) != ")") for (;;) { |
|||
var name = text.slice(pos).match(/^([^, \(\[\{]+): /); |
|||
if (name) { |
|||
pos += name[0].length; |
|||
name = name[1]; |
|||
} |
|||
args.push({name: name, type: skipMatching(/[\),]/)}); |
|||
if (text.charAt(pos) == ")") break; |
|||
pos += 2; |
|||
} |
|||
|
|||
var rettype = text.slice(pos).match(/^\) -> (.*)$/); |
|||
|
|||
return {args: args, rettype: rettype && rettype[1]}; |
|||
} |
|||
|
|||
// Moving to the definition of something
|
|||
|
|||
function jumpToDef(ts, cm) { |
|||
function inner(varName) { |
|||
var req = {type: "definition", variable: varName || null}; |
|||
var doc = findDoc(ts, cm.getDoc()); |
|||
ts.server.request(buildRequest(ts, doc, req), function(error, data) { |
|||
if (error) return showError(ts, cm, error); |
|||
if (!data.file && data.url) { window.open(data.url); return; } |
|||
|
|||
if (data.file) { |
|||
var localDoc = ts.docs[data.file], found; |
|||
if (localDoc && (found = findContext(localDoc.doc, data))) { |
|||
ts.jumpStack.push({file: doc.name, |
|||
start: cm.getCursor("from"), |
|||
end: cm.getCursor("to")}); |
|||
moveTo(ts, doc, localDoc, found.start, found.end); |
|||
return; |
|||
} |
|||
} |
|||
showError(ts, cm, "Could not find a definition."); |
|||
}); |
|||
} |
|||
|
|||
if (!atInterestingExpression(cm)) |
|||
dialog(cm, "Jump to variable", function(name) { if (name) inner(name); }); |
|||
else |
|||
inner(); |
|||
} |
|||
|
|||
function jumpBack(ts, cm) { |
|||
var pos = ts.jumpStack.pop(), doc = pos && ts.docs[pos.file]; |
|||
if (!doc) return; |
|||
moveTo(ts, findDoc(ts, cm.getDoc()), doc, pos.start, pos.end); |
|||
} |
|||
|
|||
function moveTo(ts, curDoc, doc, start, end) { |
|||
doc.doc.setSelection(start, end); |
|||
if (curDoc != doc && ts.options.switchToDoc) { |
|||
closeArgHints(ts); |
|||
ts.options.switchToDoc(doc.name, doc.doc); |
|||
} |
|||
} |
|||
|
|||
// The {line,ch} representation of positions makes this rather awkward.
|
|||
function findContext(doc, data) { |
|||
var before = data.context.slice(0, data.contextOffset).split("\n"); |
|||
var startLine = data.start.line - (before.length - 1); |
|||
var start = Pos(startLine, (before.length == 1 ? data.start.ch : doc.getLine(startLine).length) - before[0].length); |
|||
|
|||
var text = doc.getLine(startLine).slice(start.ch); |
|||
for (var cur = startLine + 1; cur < doc.lineCount() && text.length < data.context.length; ++cur) |
|||
text += "\n" + doc.getLine(cur); |
|||
if (text.slice(0, data.context.length) == data.context) return data; |
|||
|
|||
var cursor = doc.getSearchCursor(data.context, 0, false); |
|||
var nearest, nearestDist = Infinity; |
|||
while (cursor.findNext()) { |
|||
var from = cursor.from(), dist = Math.abs(from.line - start.line) * 10000; |
|||
if (!dist) dist = Math.abs(from.ch - start.ch); |
|||
if (dist < nearestDist) { nearest = from; nearestDist = dist; } |
|||
} |
|||
if (!nearest) return null; |
|||
|
|||
if (before.length == 1) |
|||
nearest.ch += before[0].length; |
|||
else |
|||
nearest = Pos(nearest.line + (before.length - 1), before[before.length - 1].length); |
|||
if (data.start.line == data.end.line) |
|||
var end = Pos(nearest.line, nearest.ch + (data.end.ch - data.start.ch)); |
|||
else |
|||
var end = Pos(nearest.line + (data.end.line - data.start.line), data.end.ch); |
|||
return {start: nearest, end: end}; |
|||
} |
|||
|
|||
function atInterestingExpression(cm) { |
|||
var pos = cm.getCursor("end"), tok = cm.getTokenAt(pos); |
|||
if (tok.start < pos.ch && (tok.type == "comment" || tok.type == "string")) return false; |
|||
return /[\w)\]]/.test(cm.getLine(pos.line).slice(Math.max(pos.ch - 1, 0), pos.ch + 1)); |
|||
} |
|||
|
|||
// Variable renaming
|
|||
|
|||
function rename(ts, cm) { |
|||
var token = cm.getTokenAt(cm.getCursor()); |
|||
if (!/\w/.test(token.string)) return showError(ts, cm, "Not at a variable"); |
|||
dialog(cm, "New name for " + token.string, function(newName) { |
|||
ts.request(cm, {type: "rename", newName: newName, fullDocs: true}, function(error, data) { |
|||
if (error) return showError(ts, cm, error); |
|||
applyChanges(ts, data.changes); |
|||
}); |
|||
}); |
|||
} |
|||
|
|||
function selectName(ts, cm) { |
|||
var name = findDoc(ts, cm.doc).name; |
|||
ts.request(cm, {type: "refs"}, function(error, data) { |
|||
if (error) return showError(ts, cm, error); |
|||
var ranges = [], cur = 0; |
|||
for (var i = 0; i < data.refs.length; i++) { |
|||
var ref = data.refs[i]; |
|||
if (ref.file == name) { |
|||
ranges.push({anchor: ref.start, head: ref.end}); |
|||
if (cmpPos(cur, ref.start) >= 0 && cmpPos(cur, ref.end) <= 0) |
|||
cur = ranges.length - 1; |
|||
} |
|||
} |
|||
cm.setSelections(ranges, cur); |
|||
}); |
|||
} |
|||
|
|||
var nextChangeOrig = 0; |
|||
function applyChanges(ts, changes) { |
|||
var perFile = Object.create(null); |
|||
for (var i = 0; i < changes.length; ++i) { |
|||
var ch = changes[i]; |
|||
(perFile[ch.file] || (perFile[ch.file] = [])).push(ch); |
|||
} |
|||
for (var file in perFile) { |
|||
var known = ts.docs[file], chs = perFile[file];; |
|||
if (!known) continue; |
|||
chs.sort(function(a, b) { return cmpPos(b.start, a.start); }); |
|||
var origin = "*rename" + (++nextChangeOrig); |
|||
for (var i = 0; i < chs.length; ++i) { |
|||
var ch = chs[i]; |
|||
known.doc.replaceRange(ch.text, ch.start, ch.end, origin); |
|||
} |
|||
} |
|||
} |
|||
|
|||
// Generic request-building helper
|
|||
|
|||
function buildRequest(ts, doc, query, pos) { |
|||
var files = [], offsetLines = 0, allowFragments = !query.fullDocs; |
|||
if (!allowFragments) delete query.fullDocs; |
|||
if (typeof query == "string") query = {type: query}; |
|||
query.lineCharPositions = true; |
|||
if (query.end == null) { |
|||
query.end = pos || doc.doc.getCursor("end"); |
|||
if (doc.doc.somethingSelected()) |
|||
query.start = doc.doc.getCursor("start"); |
|||
} |
|||
var startPos = query.start || query.end; |
|||
|
|||
if (doc.changed) { |
|||
if (doc.doc.lineCount() > bigDoc && allowFragments !== false && |
|||
doc.changed.to - doc.changed.from < 100 && |
|||
doc.changed.from <= startPos.line && doc.changed.to > query.end.line) { |
|||
files.push(getFragmentAround(doc, startPos, query.end)); |
|||
query.file = "#0"; |
|||
var offsetLines = files[0].offsetLines; |
|||
if (query.start != null) query.start = Pos(query.start.line - -offsetLines, query.start.ch); |
|||
query.end = Pos(query.end.line - offsetLines, query.end.ch); |
|||
} else { |
|||
files.push({type: "full", |
|||
name: doc.name, |
|||
text: docValue(ts, doc)}); |
|||
query.file = doc.name; |
|||
doc.changed = null; |
|||
} |
|||
} else { |
|||
query.file = doc.name; |
|||
} |
|||
for (var name in ts.docs) { |
|||
var cur = ts.docs[name]; |
|||
if (cur.changed && cur != doc) { |
|||
files.push({type: "full", name: cur.name, text: docValue(ts, cur)}); |
|||
cur.changed = null; |
|||
} |
|||
} |
|||
|
|||
return {query: query, files: files}; |
|||
} |
|||
|
|||
function getFragmentAround(data, start, end) { |
|||
var doc = data.doc; |
|||
var minIndent = null, minLine = null, endLine, tabSize = 4; |
|||
for (var p = start.line - 1, min = Math.max(0, p - 50); p >= min; --p) { |
|||
var line = doc.getLine(p), fn = line.search(/\bfunction\b/); |
|||
if (fn < 0) continue; |
|||
var indent = CodeMirror.countColumn(line, null, tabSize); |
|||
if (minIndent != null && minIndent <= indent) continue; |
|||
minIndent = indent; |
|||
minLine = p; |
|||
} |
|||
if (minLine == null) minLine = min; |
|||
var max = Math.min(doc.lastLine(), end.line + 20); |
|||
if (minIndent == null || minIndent == CodeMirror.countColumn(doc.getLine(start.line), null, tabSize)) |
|||
endLine = max; |
|||
else for (endLine = end.line + 1; endLine < max; ++endLine) { |
|||
var indent = CodeMirror.countColumn(doc.getLine(endLine), null, tabSize); |
|||
if (indent <= minIndent) break; |
|||
} |
|||
var from = Pos(minLine, 0); |
|||
|
|||
return {type: "part", |
|||
name: data.name, |
|||
offsetLines: from.line, |
|||
text: doc.getRange(from, Pos(endLine, 0))}; |
|||
} |
|||
|
|||
// Generic utilities
|
|||
|
|||
var cmpPos = CodeMirror.cmpPos; |
|||
|
|||
function elt(tagname, cls /*, ... elts*/) { |
|||
var e = document.createElement(tagname); |
|||
if (cls) e.className = cls; |
|||
for (var i = 2; i < arguments.length; ++i) { |
|||
var elt = arguments[i]; |
|||
if (typeof elt == "string") elt = document.createTextNode(elt); |
|||
e.appendChild(elt); |
|||
} |
|||
return e; |
|||
} |
|||
|
|||
function dialog(cm, text, f) { |
|||
if (cm.openDialog) |
|||
cm.openDialog(text + ": <input type=text>", f); |
|||
else |
|||
f(prompt(text, "")); |
|||
} |
|||
|
|||
// Tooltips
|
|||
|
|||
function tempTooltip(cm, content) { |
|||
if (cm.state.ternTooltip) remove(cm.state.ternTooltip); |
|||
var where = cm.cursorCoords(); |
|||
var tip = cm.state.ternTooltip = makeTooltip(where.right + 1, where.bottom, content); |
|||
function maybeClear() { |
|||
old = true; |
|||
if (!mouseOnTip) clear(); |
|||
} |
|||
function clear() { |
|||
cm.state.ternTooltip = null; |
|||
if (!tip.parentNode) return; |
|||
cm.off("cursorActivity", clear); |
|||
cm.off('blur', clear); |
|||
cm.off('scroll', clear); |
|||
fadeOut(tip); |
|||
} |
|||
var mouseOnTip = false, old = false; |
|||
CodeMirror.on(tip, "mousemove", function() { mouseOnTip = true; }); |
|||
CodeMirror.on(tip, "mouseout", function(e) { |
|||
if (!CodeMirror.contains(tip, e.relatedTarget || e.toElement)) { |
|||
if (old) clear(); |
|||
else mouseOnTip = false; |
|||
} |
|||
}); |
|||
setTimeout(maybeClear, 1700); |
|||
cm.on("cursorActivity", clear); |
|||
cm.on('blur', clear); |
|||
cm.on('scroll', clear); |
|||
} |
|||
|
|||
function makeTooltip(x, y, content) { |
|||
var node = elt("div", cls + "tooltip", content); |
|||
node.style.left = x + "px"; |
|||
node.style.top = y + "px"; |
|||
document.body.appendChild(node); |
|||
return node; |
|||
} |
|||
|
|||
function remove(node) { |
|||
var p = node && node.parentNode; |
|||
if (p) p.removeChild(node); |
|||
} |
|||
|
|||
function fadeOut(tooltip) { |
|||
tooltip.style.opacity = "0"; |
|||
setTimeout(function() { remove(tooltip); }, 1100); |
|||
} |
|||
|
|||
function showError(ts, cm, msg) { |
|||
if (ts.options.showError) |
|||
ts.options.showError(cm, msg); |
|||
else |
|||
tempTooltip(cm, String(msg)); |
|||
} |
|||
|
|||
function closeArgHints(ts) { |
|||
if (ts.activeArgHints) { remove(ts.activeArgHints); ts.activeArgHints = null; } |
|||
} |
|||
|
|||
function docValue(ts, doc) { |
|||
var val = doc.doc.getValue(); |
|||
if (ts.options.fileFilter) val = ts.options.fileFilter(val, doc.name, doc.doc); |
|||
return val; |
|||
} |
|||
|
|||
// Worker wrapper
|
|||
|
|||
function WorkerServer(ts) { |
|||
var worker = ts.worker = new Worker(ts.options.workerScript); |
|||
worker.postMessage({type: "init", |
|||
defs: ts.options.defs, |
|||
plugins: ts.options.plugins, |
|||
scripts: ts.options.workerDeps}); |
|||
var msgId = 0, pending = {}; |
|||
|
|||
function send(data, c) { |
|||
if (c) { |
|||
data.id = ++msgId; |
|||
pending[msgId] = c; |
|||
} |
|||
worker.postMessage(data); |
|||
} |
|||
worker.onmessage = function(e) { |
|||
var data = e.data; |
|||
if (data.type == "getFile") { |
|||
getFile(ts, data.name, function(err, text) { |
|||
send({type: "getFile", err: String(err), text: text, id: data.id}); |
|||
}); |
|||
} else if (data.type == "debug") { |
|||
window.console.log(data.message); |
|||
} else if (data.id && pending[data.id]) { |
|||
pending[data.id](data.err, data.body); |
|||
delete pending[data.id]; |
|||
} |
|||
}; |
|||
worker.onerror = function(e) { |
|||
for (var id in pending) pending[id](e); |
|||
pending = {}; |
|||
}; |
|||
|
|||
this.addFile = function(name, text) { send({type: "add", name: name, text: text}); }; |
|||
this.delFile = function(name) { send({type: "del", name: name}); }; |
|||
this.request = function(body, c) { send({type: "req", body: body}, c); }; |
|||
} |
|||
}); |
|||
@ -0,0 +1,994 @@ |
|||
// The Tern server object
|
|||
|
|||
// A server is a stateful object that manages the analysis for a
|
|||
// project, and defines an interface for querying the code in the
|
|||
// project.
|
|||
|
|||
(function(root, mod) { |
|||
if (typeof exports == "object" && typeof module == "object") // CommonJS
|
|||
return mod(exports, require("./infer"), require("./signal"), |
|||
require("acorn/acorn"), require("acorn/util/walk")); |
|||
if (typeof define == "function" && define.amd) // AMD
|
|||
return define(["exports", "./infer", "./signal", "acorn/acorn", "acorn/util/walk"], mod); |
|||
mod(root.tern || (root.tern = {}), tern, tern.signal, acorn, acorn.walk); // Plain browser env
|
|||
})(this, function(exports, infer, signal, acorn, walk) { |
|||
"use strict"; |
|||
|
|||
var plugins = Object.create(null); |
|||
exports.registerPlugin = function(name, init) { plugins[name] = init; }; |
|||
|
|||
var defaultOptions = exports.defaultOptions = { |
|||
debug: false, |
|||
async: false, |
|||
getFile: function(_f, c) { if (this.async) c(null, null); }, |
|||
defs: [], |
|||
plugins: {}, |
|||
fetchTimeout: 1000, |
|||
dependencyBudget: 20000, |
|||
reuseInstances: true, |
|||
stripCRs: false |
|||
}; |
|||
|
|||
var queryTypes = { |
|||
completions: { |
|||
takesFile: true, |
|||
run: findCompletions |
|||
}, |
|||
properties: { |
|||
run: findProperties |
|||
}, |
|||
type: { |
|||
takesFile: true, |
|||
run: findTypeAt |
|||
}, |
|||
documentation: { |
|||
takesFile: true, |
|||
run: findDocs |
|||
}, |
|||
definition: { |
|||
takesFile: true, |
|||
run: findDef |
|||
}, |
|||
refs: { |
|||
takesFile: true, |
|||
fullFile: true, |
|||
run: findRefs |
|||
}, |
|||
rename: { |
|||
takesFile: true, |
|||
fullFile: true, |
|||
run: buildRename |
|||
}, |
|||
files: { |
|||
run: listFiles |
|||
} |
|||
}; |
|||
|
|||
exports.defineQueryType = function(name, desc) { queryTypes[name] = desc; }; |
|||
|
|||
function File(name, parent) { |
|||
this.name = name; |
|||
this.parent = parent; |
|||
this.scope = this.text = this.ast = this.lineOffsets = null; |
|||
} |
|||
File.prototype.asLineChar = function(pos) { return asLineChar(this, pos); }; |
|||
|
|||
function updateText(file, text, srv) { |
|||
file.text = srv.options.stripCRs ? text.replace(/\r\n/g, "\n") : text; |
|||
infer.withContext(srv.cx, function() { |
|||
file.ast = infer.parse(file.text, srv.passes, {directSourceFile: file, allowReturnOutsideFunction: true}); |
|||
}); |
|||
file.lineOffsets = null; |
|||
} |
|||
|
|||
var Server = exports.Server = function(options) { |
|||
this.cx = null; |
|||
this.options = options || {}; |
|||
for (var o in defaultOptions) if (!options.hasOwnProperty(o)) |
|||
options[o] = defaultOptions[o]; |
|||
|
|||
this.handlers = Object.create(null); |
|||
this.files = []; |
|||
this.fileMap = Object.create(null); |
|||
this.needsPurge = []; |
|||
this.budgets = Object.create(null); |
|||
this.uses = 0; |
|||
this.pending = 0; |
|||
this.asyncError = null; |
|||
this.passes = Object.create(null); |
|||
|
|||
this.defs = options.defs.slice(0); |
|||
for (var plugin in options.plugins) if (options.plugins.hasOwnProperty(plugin) && plugin in plugins) { |
|||
var init = plugins[plugin](this, options.plugins[plugin]); |
|||
if (init && init.defs) { |
|||
if (init.loadFirst) this.defs.unshift(init.defs); |
|||
else this.defs.push(init.defs); |
|||
} |
|||
if (init && init.passes) for (var type in init.passes) if (init.passes.hasOwnProperty(type)) |
|||
(this.passes[type] || (this.passes[type] = [])).push(init.passes[type]); |
|||
} |
|||
|
|||
this.reset(); |
|||
}; |
|||
Server.prototype = signal.mixin({ |
|||
addFile: function(name, /*optional*/ text, parent) { |
|||
// Don't crash when sloppy plugins pass non-existent parent ids
|
|||
if (parent && !(parent in this.fileMap)) parent = null; |
|||
ensureFile(this, name, parent, text); |
|||
}, |
|||
delFile: function(name) { |
|||
var file = this.findFile(name); |
|||
if (file) { |
|||
this.needsPurge.push(file.name); |
|||
this.files.splice(this.files.indexOf(file), 1); |
|||
delete this.fileMap[name]; |
|||
} |
|||
}, |
|||
reset: function() { |
|||
this.signal("reset"); |
|||
this.cx = new infer.Context(this.defs, this); |
|||
this.uses = 0; |
|||
this.budgets = Object.create(null); |
|||
for (var i = 0; i < this.files.length; ++i) { |
|||
var file = this.files[i]; |
|||
file.scope = null; |
|||
} |
|||
}, |
|||
|
|||
request: function(doc, c) { |
|||
var inv = invalidDoc(doc); |
|||
if (inv) return c(inv); |
|||
|
|||
var self = this; |
|||
doRequest(this, doc, function(err, data) { |
|||
c(err, data); |
|||
if (self.uses > 40) { |
|||
self.reset(); |
|||
analyzeAll(self, null, function(){}); |
|||
} |
|||
}); |
|||
}, |
|||
|
|||
findFile: function(name) { |
|||
return this.fileMap[name]; |
|||
}, |
|||
|
|||
flush: function(c) { |
|||
var cx = this.cx; |
|||
analyzeAll(this, null, function(err) { |
|||
if (err) return c(err); |
|||
infer.withContext(cx, c); |
|||
}); |
|||
}, |
|||
|
|||
startAsyncAction: function() { |
|||
++this.pending; |
|||
}, |
|||
finishAsyncAction: function(err) { |
|||
if (err) this.asyncError = err; |
|||
if (--this.pending === 0) this.signal("everythingFetched"); |
|||
} |
|||
}); |
|||
|
|||
function doRequest(srv, doc, c) { |
|||
if (doc.query && !queryTypes.hasOwnProperty(doc.query.type)) |
|||
return c("No query type '" + doc.query.type + "' defined"); |
|||
|
|||
var query = doc.query; |
|||
// Respond as soon as possible when this just uploads files
|
|||
if (!query) c(null, {}); |
|||
|
|||
var files = doc.files || []; |
|||
if (files.length) ++srv.uses; |
|||
for (var i = 0; i < files.length; ++i) { |
|||
var file = files[i]; |
|||
if (file.type == "delete") |
|||
srv.delFile(file.name); |
|||
else |
|||
ensureFile(srv, file.name, null, file.type == "full" ? file.text : null); |
|||
} |
|||
|
|||
var timeBudget = typeof doc.timeout == "number" ? [doc.timeout] : null; |
|||
if (!query) { |
|||
analyzeAll(srv, timeBudget, function(){}); |
|||
return; |
|||
} |
|||
|
|||
var queryType = queryTypes[query.type]; |
|||
if (queryType.takesFile) { |
|||
if (typeof query.file != "string") return c(".query.file must be a string"); |
|||
if (!/^#/.test(query.file)) ensureFile(srv, query.file, null); |
|||
} |
|||
|
|||
analyzeAll(srv, timeBudget, function(err) { |
|||
if (err) return c(err); |
|||
var file = queryType.takesFile && resolveFile(srv, files, query.file); |
|||
if (queryType.fullFile && file.type == "part") |
|||
return c("Can't run a " + query.type + " query on a file fragment"); |
|||
|
|||
function run() { |
|||
var result; |
|||
try { |
|||
result = queryType.run(srv, query, file); |
|||
} catch (e) { |
|||
if (srv.options.debug && e.name != "TernError") console.error(e.stack); |
|||
return c(e); |
|||
} |
|||
c(null, result); |
|||
} |
|||
infer.withContext(srv.cx, timeBudget ? function() { infer.withTimeout(timeBudget[0], run); } : run); |
|||
}); |
|||
} |
|||
|
|||
function analyzeFile(srv, file) { |
|||
infer.withContext(srv.cx, function() { |
|||
file.scope = srv.cx.topScope; |
|||
srv.signal("beforeLoad", file); |
|||
infer.analyze(file.ast, file.name, file.scope, srv.passes); |
|||
srv.signal("afterLoad", file); |
|||
}); |
|||
return file; |
|||
} |
|||
|
|||
function ensureFile(srv, name, parent, text) { |
|||
var known = srv.findFile(name); |
|||
if (known) { |
|||
if (text != null) { |
|||
if (known.scope) { |
|||
srv.needsPurge.push(name); |
|||
known.scope = null; |
|||
} |
|||
updateText(known, text, srv); |
|||
} |
|||
if (parentDepth(srv, known.parent) > parentDepth(srv, parent)) { |
|||
known.parent = parent; |
|||
if (known.excluded) known.excluded = null; |
|||
} |
|||
return; |
|||
} |
|||
|
|||
var file = new File(name, parent); |
|||
srv.files.push(file); |
|||
srv.fileMap[name] = file; |
|||
if (text != null) { |
|||
updateText(file, text, srv); |
|||
} else if (srv.options.async) { |
|||
srv.startAsyncAction(); |
|||
srv.options.getFile(name, function(err, text) { |
|||
updateText(file, text || "", srv); |
|||
srv.finishAsyncAction(err); |
|||
}); |
|||
} else { |
|||
updateText(file, srv.options.getFile(name) || "", srv); |
|||
} |
|||
} |
|||
|
|||
function fetchAll(srv, c) { |
|||
var done = true, returned = false; |
|||
srv.files.forEach(function(file) { |
|||
if (file.text != null) return; |
|||
if (srv.options.async) { |
|||
done = false; |
|||
srv.options.getFile(file.name, function(err, text) { |
|||
if (err && !returned) { returned = true; return c(err); } |
|||
updateText(file, text || "", srv); |
|||
fetchAll(srv, c); |
|||
}); |
|||
} else { |
|||
try { |
|||
updateText(file, srv.options.getFile(file.name) || "", srv); |
|||
} catch (e) { return c(e); } |
|||
} |
|||
}); |
|||
if (done) c(); |
|||
} |
|||
|
|||
function waitOnFetch(srv, timeBudget, c) { |
|||
var done = function() { |
|||
srv.off("everythingFetched", done); |
|||
clearTimeout(timeout); |
|||
analyzeAll(srv, timeBudget, c); |
|||
}; |
|||
srv.on("everythingFetched", done); |
|||
var timeout = setTimeout(done, srv.options.fetchTimeout); |
|||
} |
|||
|
|||
function analyzeAll(srv, timeBudget, c) { |
|||
if (srv.pending) return waitOnFetch(srv, timeBudget, c); |
|||
|
|||
var e = srv.fetchError; |
|||
if (e) { srv.fetchError = null; return c(e); } |
|||
|
|||
if (srv.needsPurge.length > 0) infer.withContext(srv.cx, function() { |
|||
infer.purge(srv.needsPurge); |
|||
srv.needsPurge.length = 0; |
|||
}); |
|||
|
|||
var done = true; |
|||
// The second inner loop might add new files. The outer loop keeps
|
|||
// repeating both inner loops until all files have been looked at.
|
|||
for (var i = 0; i < srv.files.length;) { |
|||
var toAnalyze = []; |
|||
for (; i < srv.files.length; ++i) { |
|||
var file = srv.files[i]; |
|||
if (file.text == null) done = false; |
|||
else if (file.scope == null && !file.excluded) toAnalyze.push(file); |
|||
} |
|||
toAnalyze.sort(function(a, b) { |
|||
return parentDepth(srv, a.parent) - parentDepth(srv, b.parent); |
|||
}); |
|||
for (var j = 0; j < toAnalyze.length; j++) { |
|||
var file = toAnalyze[j]; |
|||
if (file.parent && !chargeOnBudget(srv, file)) { |
|||
file.excluded = true; |
|||
} else if (timeBudget) { |
|||
var startTime = +new Date; |
|||
infer.withTimeout(timeBudget[0], function() { analyzeFile(srv, file); }); |
|||
timeBudget[0] -= +new Date - startTime; |
|||
} else { |
|||
analyzeFile(srv, file); |
|||
} |
|||
} |
|||
} |
|||
if (done) c(); |
|||
else waitOnFetch(srv, timeBudget, c); |
|||
} |
|||
|
|||
function firstLine(str) { |
|||
var end = str.indexOf("\n"); |
|||
if (end < 0) return str; |
|||
return str.slice(0, end); |
|||
} |
|||
|
|||
function findMatchingPosition(line, file, near) { |
|||
var pos = Math.max(0, near - 500), closest = null; |
|||
if (!/^\s*$/.test(line)) for (;;) { |
|||
var found = file.indexOf(line, pos); |
|||
if (found < 0 || found > near + 500) break; |
|||
if (closest == null || Math.abs(closest - near) > Math.abs(found - near)) |
|||
closest = found; |
|||
pos = found + line.length; |
|||
} |
|||
return closest; |
|||
} |
|||
|
|||
function scopeDepth(s) { |
|||
for (var i = 0; s; ++i, s = s.prev) {} |
|||
return i; |
|||
} |
|||
|
|||
function ternError(msg) { |
|||
var err = new Error(msg); |
|||
err.name = "TernError"; |
|||
return err; |
|||
} |
|||
|
|||
function resolveFile(srv, localFiles, name) { |
|||
var isRef = name.match(/^#(\d+)$/); |
|||
if (!isRef) return srv.findFile(name); |
|||
|
|||
var file = localFiles[isRef[1]]; |
|||
if (!file || file.type == "delete") throw ternError("Reference to unknown file " + name); |
|||
if (file.type == "full") return srv.findFile(file.name); |
|||
|
|||
// This is a partial file
|
|||
|
|||
var realFile = file.backing = srv.findFile(file.name); |
|||
var offset = file.offset; |
|||
if (file.offsetLines) offset = {line: file.offsetLines, ch: 0}; |
|||
file.offset = offset = resolvePos(realFile, file.offsetLines == null ? file.offset : {line: file.offsetLines, ch: 0}, true); |
|||
var line = firstLine(file.text); |
|||
var foundPos = findMatchingPosition(line, realFile.text, offset); |
|||
var pos = foundPos == null ? Math.max(0, realFile.text.lastIndexOf("\n", offset)) : foundPos; |
|||
var inObject, atFunction; |
|||
|
|||
infer.withContext(srv.cx, function() { |
|||
infer.purge(file.name, pos, pos + file.text.length); |
|||
|
|||
var text = file.text, m; |
|||
if (m = text.match(/(?:"([^"]*)"|([\w$]+))\s*:\s*function\b/)) { |
|||
var objNode = walk.findNodeAround(file.backing.ast, pos, "ObjectExpression"); |
|||
if (objNode && objNode.node.objType) |
|||
inObject = {type: objNode.node.objType, prop: m[2] || m[1]}; |
|||
} |
|||
if (foundPos && (m = line.match(/^(.*?)\bfunction\b/))) { |
|||
var cut = m[1].length, white = ""; |
|||
for (var i = 0; i < cut; ++i) white += " "; |
|||
text = white + text.slice(cut); |
|||
atFunction = true; |
|||
} |
|||
|
|||
var scopeStart = infer.scopeAt(realFile.ast, pos, realFile.scope); |
|||
var scopeEnd = infer.scopeAt(realFile.ast, pos + text.length, realFile.scope); |
|||
var scope = file.scope = scopeDepth(scopeStart) < scopeDepth(scopeEnd) ? scopeEnd : scopeStart; |
|||
file.ast = infer.parse(text, srv.passes, {directSourceFile: file, allowReturnOutsideFunction: true}); |
|||
infer.analyze(file.ast, file.name, scope, srv.passes); |
|||
|
|||
// This is a kludge to tie together the function types (if any)
|
|||
// outside and inside of the fragment, so that arguments and
|
|||
// return values have some information known about them.
|
|||
tieTogether: if (inObject || atFunction) { |
|||
var newInner = infer.scopeAt(file.ast, line.length, scopeStart); |
|||
if (!newInner.fnType) break tieTogether; |
|||
if (inObject) { |
|||
var prop = inObject.type.getProp(inObject.prop); |
|||
prop.addType(newInner.fnType); |
|||
} else if (atFunction) { |
|||
var inner = infer.scopeAt(realFile.ast, pos + line.length, realFile.scope); |
|||
if (inner == scopeStart || !inner.fnType) break tieTogether; |
|||
var fOld = inner.fnType, fNew = newInner.fnType; |
|||
if (!fNew || (fNew.name != fOld.name && fOld.name)) break tieTogether; |
|||
for (var i = 0, e = Math.min(fOld.args.length, fNew.args.length); i < e; ++i) |
|||
fOld.args[i].propagate(fNew.args[i]); |
|||
fOld.self.propagate(fNew.self); |
|||
fNew.retval.propagate(fOld.retval); |
|||
} |
|||
} |
|||
}); |
|||
return file; |
|||
} |
|||
|
|||
// Budget management
|
|||
|
|||
function astSize(node) { |
|||
var size = 0; |
|||
walk.simple(node, {Expression: function() { ++size; }}); |
|||
return size; |
|||
} |
|||
|
|||
function parentDepth(srv, parent) { |
|||
var depth = 0; |
|||
while (parent) { |
|||
parent = srv.findFile(parent).parent; |
|||
++depth; |
|||
} |
|||
return depth; |
|||
} |
|||
|
|||
function budgetName(srv, file) { |
|||
for (;;) { |
|||
var parent = srv.findFile(file.parent); |
|||
if (!parent.parent) break; |
|||
file = parent; |
|||
} |
|||
return file.name; |
|||
} |
|||
|
|||
function chargeOnBudget(srv, file) { |
|||
var bName = budgetName(srv, file); |
|||
var size = astSize(file.ast); |
|||
var known = srv.budgets[bName]; |
|||
if (known == null) |
|||
known = srv.budgets[bName] = srv.options.dependencyBudget; |
|||
if (known < size) return false; |
|||
srv.budgets[bName] = known - size; |
|||
return true; |
|||
} |
|||
|
|||
// Query helpers
|
|||
|
|||
function isPosition(val) { |
|||
return typeof val == "number" || typeof val == "object" && |
|||
typeof val.line == "number" && typeof val.ch == "number"; |
|||
} |
|||
|
|||
// Baseline query document validation
|
|||
function invalidDoc(doc) { |
|||
if (doc.query) { |
|||
if (typeof doc.query.type != "string") return ".query.type must be a string"; |
|||
if (doc.query.start && !isPosition(doc.query.start)) return ".query.start must be a position"; |
|||
if (doc.query.end && !isPosition(doc.query.end)) return ".query.end must be a position"; |
|||
} |
|||
if (doc.files) { |
|||
if (!Array.isArray(doc.files)) return "Files property must be an array"; |
|||
for (var i = 0; i < doc.files.length; ++i) { |
|||
var file = doc.files[i]; |
|||
if (typeof file != "object") return ".files[n] must be objects"; |
|||
else if (typeof file.name != "string") return ".files[n].name must be a string"; |
|||
else if (file.type == "delete") continue; |
|||
else if (typeof file.text != "string") return ".files[n].text must be a string"; |
|||
else if (file.type == "part") { |
|||
if (!isPosition(file.offset) && typeof file.offsetLines != "number") |
|||
return ".files[n].offset must be a position"; |
|||
} else if (file.type != "full") return ".files[n].type must be \"full\" or \"part\""; |
|||
} |
|||
} |
|||
} |
|||
|
|||
var offsetSkipLines = 25; |
|||
|
|||
function findLineStart(file, line) { |
|||
var text = file.text, offsets = file.lineOffsets || (file.lineOffsets = [0]); |
|||
var pos = 0, curLine = 0; |
|||
var storePos = Math.min(Math.floor(line / offsetSkipLines), offsets.length - 1); |
|||
var pos = offsets[storePos], curLine = storePos * offsetSkipLines; |
|||
|
|||
while (curLine < line) { |
|||
++curLine; |
|||
pos = text.indexOf("\n", pos) + 1; |
|||
if (pos === 0) return null; |
|||
if (curLine % offsetSkipLines === 0) offsets.push(pos); |
|||
} |
|||
return pos; |
|||
} |
|||
|
|||
var resolvePos = exports.resolvePos = function(file, pos, tolerant) { |
|||
if (typeof pos != "number") { |
|||
var lineStart = findLineStart(file, pos.line); |
|||
if (lineStart == null) { |
|||
if (tolerant) pos = file.text.length; |
|||
else throw ternError("File doesn't contain a line " + pos.line); |
|||
} else { |
|||
pos = lineStart + pos.ch; |
|||
} |
|||
} |
|||
if (pos > file.text.length) { |
|||
if (tolerant) pos = file.text.length; |
|||
else throw ternError("Position " + pos + " is outside of file."); |
|||
} |
|||
return pos; |
|||
}; |
|||
|
|||
function asLineChar(file, pos) { |
|||
if (!file) return {line: 0, ch: 0}; |
|||
var offsets = file.lineOffsets || (file.lineOffsets = [0]); |
|||
var text = file.text, line, lineStart; |
|||
for (var i = offsets.length - 1; i >= 0; --i) if (offsets[i] <= pos) { |
|||
line = i * offsetSkipLines; |
|||
lineStart = offsets[i]; |
|||
} |
|||
for (;;) { |
|||
var eol = text.indexOf("\n", lineStart); |
|||
if (eol >= pos || eol < 0) break; |
|||
lineStart = eol + 1; |
|||
++line; |
|||
} |
|||
return {line: line, ch: pos - lineStart}; |
|||
} |
|||
|
|||
var outputPos = exports.outputPos = function(query, file, pos) { |
|||
if (query.lineCharPositions) { |
|||
var out = asLineChar(file, pos); |
|||
if (file.type == "part") |
|||
out.line += file.offsetLines != null ? file.offsetLines : asLineChar(file.backing, file.offset).line; |
|||
return out; |
|||
} else { |
|||
return pos + (file.type == "part" ? file.offset : 0); |
|||
} |
|||
}; |
|||
|
|||
// Delete empty fields from result objects
|
|||
function clean(obj) { |
|||
for (var prop in obj) if (obj[prop] == null) delete obj[prop]; |
|||
return obj; |
|||
} |
|||
function maybeSet(obj, prop, val) { |
|||
if (val != null) obj[prop] = val; |
|||
} |
|||
|
|||
// Built-in query types
|
|||
|
|||
function compareCompletions(a, b) { |
|||
if (typeof a != "string") { a = a.name; b = b.name; } |
|||
var aUp = /^[A-Z]/.test(a), bUp = /^[A-Z]/.test(b); |
|||
if (aUp == bUp) return a < b ? -1 : a == b ? 0 : 1; |
|||
else return aUp ? 1 : -1; |
|||
} |
|||
|
|||
function isStringAround(node, start, end) { |
|||
return node.type == "Literal" && typeof node.value == "string" && |
|||
node.start == start - 1 && node.end <= end + 1; |
|||
} |
|||
|
|||
function pointInProp(objNode, point) { |
|||
for (var i = 0; i < objNode.properties.length; i++) { |
|||
var curProp = objNode.properties[i]; |
|||
if (curProp.key.start <= point && curProp.key.end >= point) |
|||
return curProp; |
|||
} |
|||
} |
|||
|
|||
var jsKeywords = ("break do instanceof typeof case else new var " + |
|||
"catch finally return void continue for switch while debugger " + |
|||
"function this with default if throw delete in try").split(" "); |
|||
|
|||
function findCompletions(srv, query, file) { |
|||
if (query.end == null) throw ternError("missing .query.end field"); |
|||
if (srv.passes.completion) for (var i = 0; i < srv.passes.completion.length; i++) { |
|||
var result = srv.passes.completion[i](file, query); |
|||
if (result) return result; |
|||
} |
|||
|
|||
var wordStart = resolvePos(file, query.end), wordEnd = wordStart, text = file.text; |
|||
while (wordStart && acorn.isIdentifierChar(text.charCodeAt(wordStart - 1))) --wordStart; |
|||
if (query.expandWordForward !== false) |
|||
while (wordEnd < text.length && acorn.isIdentifierChar(text.charCodeAt(wordEnd))) ++wordEnd; |
|||
var word = text.slice(wordStart, wordEnd), completions = [], ignoreObj; |
|||
if (query.caseInsensitive) word = word.toLowerCase(); |
|||
var wrapAsObjs = query.types || query.depths || query.docs || query.urls || query.origins; |
|||
|
|||
function gather(prop, obj, depth, addInfo) { |
|||
// 'hasOwnProperty' and such are usually just noise, leave them
|
|||
// out when no prefix is provided.
|
|||
if (query.omitObjectPrototype !== false && obj == srv.cx.protos.Object && !word) return; |
|||
if (query.filter !== false && word && |
|||
(query.caseInsensitive ? prop.toLowerCase() : prop).indexOf(word) !== 0) return; |
|||
if (ignoreObj && ignoreObj.props[prop]) return; |
|||
for (var i = 0; i < completions.length; ++i) { |
|||
var c = completions[i]; |
|||
if ((wrapAsObjs ? c.name : c) == prop) return; |
|||
} |
|||
var rec = wrapAsObjs ? {name: prop} : prop; |
|||
completions.push(rec); |
|||
|
|||
if (obj && (query.types || query.docs || query.urls || query.origins)) { |
|||
var val = obj.props[prop]; |
|||
infer.resetGuessing(); |
|||
var type = val.getType(); |
|||
rec.guess = infer.didGuess(); |
|||
if (query.types) |
|||
rec.type = infer.toString(val); |
|||
if (query.docs) |
|||
maybeSet(rec, "doc", val.doc || type && type.doc); |
|||
if (query.urls) |
|||
maybeSet(rec, "url", val.url || type && type.url); |
|||
if (query.origins) |
|||
maybeSet(rec, "origin", val.origin || type && type.origin); |
|||
} |
|||
if (query.depths) rec.depth = depth; |
|||
if (wrapAsObjs && addInfo) addInfo(rec); |
|||
} |
|||
|
|||
var hookname, prop, objType, isKey; |
|||
|
|||
var exprAt = infer.findExpressionAround(file.ast, null, wordStart, file.scope); |
|||
var memberExpr, objLit; |
|||
// Decide whether this is an object property, either in a member
|
|||
// expression or an object literal.
|
|||
if (exprAt) { |
|||
if (exprAt.node.type == "MemberExpression" && exprAt.node.object.end < wordStart) { |
|||
memberExpr = exprAt; |
|||
} else if (isStringAround(exprAt.node, wordStart, wordEnd)) { |
|||
var parent = infer.parentNode(exprAt.node, file.ast); |
|||
if (parent.type == "MemberExpression" && parent.property == exprAt.node) |
|||
memberExpr = {node: parent, state: exprAt.state}; |
|||
} else if (exprAt.node.type == "ObjectExpression") { |
|||
var objProp = pointInProp(exprAt.node, wordEnd); |
|||
if (objProp) { |
|||
objLit = exprAt; |
|||
prop = isKey = objProp.key.name; |
|||
} else if (!word && !/:\s*$/.test(file.text.slice(0, wordStart))) { |
|||
objLit = exprAt; |
|||
prop = isKey = true; |
|||
} |
|||
} |
|||
} |
|||
|
|||
if (objLit) { |
|||
// Since we can't use the type of the literal itself to complete
|
|||
// its properties (it doesn't contain the information we need),
|
|||
// we have to try asking the surrounding expression for type info.
|
|||
objType = infer.typeFromContext(file.ast, objLit); |
|||
ignoreObj = objLit.node.objType; |
|||
} else if (memberExpr) { |
|||
prop = memberExpr.node.property; |
|||
prop = prop.type == "Literal" ? prop.value.slice(1) : prop.name; |
|||
memberExpr.node = memberExpr.node.object; |
|||
objType = infer.expressionType(memberExpr); |
|||
} else if (text.charAt(wordStart - 1) == ".") { |
|||
var pathStart = wordStart - 1; |
|||
while (pathStart && (text.charAt(pathStart - 1) == "." || acorn.isIdentifierChar(text.charCodeAt(pathStart - 1)))) pathStart--; |
|||
var path = text.slice(pathStart, wordStart - 1); |
|||
if (path) { |
|||
objType = infer.def.parsePath(path, file.scope).getObjType(); |
|||
prop = word; |
|||
} |
|||
} |
|||
|
|||
if (prop != null) { |
|||
srv.cx.completingProperty = prop; |
|||
|
|||
if (objType) infer.forAllPropertiesOf(objType, gather); |
|||
|
|||
if (!completions.length && query.guess !== false && objType && objType.guessProperties) |
|||
objType.guessProperties(function(p, o, d) {if (p != prop && p != "✖") gather(p, o, d);}); |
|||
if (!completions.length && word.length >= 2 && query.guess !== false) |
|||
for (var prop in srv.cx.props) gather(prop, srv.cx.props[prop][0], 0); |
|||
hookname = "memberCompletion"; |
|||
} else { |
|||
infer.forAllLocalsAt(file.ast, wordStart, file.scope, gather); |
|||
if (query.includeKeywords) jsKeywords.forEach(function(kw) { |
|||
gather(kw, null, 0, function(rec) { rec.isKeyword = true; }); |
|||
}); |
|||
hookname = "variableCompletion"; |
|||
} |
|||
if (srv.passes[hookname]) |
|||
srv.passes[hookname].forEach(function(hook) {hook(file, wordStart, wordEnd, gather);}); |
|||
|
|||
if (query.sort !== false) completions.sort(compareCompletions); |
|||
srv.cx.completingProperty = null; |
|||
|
|||
return {start: outputPos(query, file, wordStart), |
|||
end: outputPos(query, file, wordEnd), |
|||
isProperty: !!prop, |
|||
isObjectKey: !!isKey, |
|||
completions: completions}; |
|||
} |
|||
|
|||
function findProperties(srv, query) { |
|||
var prefix = query.prefix, found = []; |
|||
for (var prop in srv.cx.props) |
|||
if (prop != "<i>" && (!prefix || prop.indexOf(prefix) === 0)) found.push(prop); |
|||
if (query.sort !== false) found.sort(compareCompletions); |
|||
return {completions: found}; |
|||
} |
|||
|
|||
var findExpr = exports.findQueryExpr = function(file, query, wide) { |
|||
if (query.end == null) throw ternError("missing .query.end field"); |
|||
|
|||
if (query.variable) { |
|||
var scope = infer.scopeAt(file.ast, resolvePos(file, query.end), file.scope); |
|||
return {node: {type: "Identifier", name: query.variable, start: query.end, end: query.end + 1}, |
|||
state: scope}; |
|||
} else { |
|||
var start = query.start && resolvePos(file, query.start), end = resolvePos(file, query.end); |
|||
var expr = infer.findExpressionAt(file.ast, start, end, file.scope); |
|||
if (expr) return expr; |
|||
expr = infer.findExpressionAround(file.ast, start, end, file.scope); |
|||
if (expr && (expr.node.type == "ObjectExpression" || wide || |
|||
(start == null ? end : start) - expr.node.start < 20 || expr.node.end - end < 20)) |
|||
return expr; |
|||
return null; |
|||
} |
|||
}; |
|||
|
|||
function findExprOrThrow(file, query, wide) { |
|||
var expr = findExpr(file, query, wide); |
|||
if (expr) return expr; |
|||
throw ternError("No expression at the given position."); |
|||
} |
|||
|
|||
function ensureObj(tp) { |
|||
if (!tp || !(tp = tp.getType()) || !(tp instanceof infer.Obj)) return null; |
|||
return tp; |
|||
} |
|||
|
|||
function findExprType(srv, query, file, expr) { |
|||
var type; |
|||
if (expr) { |
|||
infer.resetGuessing(); |
|||
type = infer.expressionType(expr); |
|||
} |
|||
if (srv.passes["typeAt"]) { |
|||
var pos = resolvePos(file, query.end); |
|||
srv.passes["typeAt"].forEach(function(hook) { |
|||
type = hook(file, pos, expr, type); |
|||
}); |
|||
} |
|||
if (!type) throw ternError("No type found at the given position."); |
|||
|
|||
var objProp; |
|||
if (expr.node.type == "ObjectExpression" && query.end != null && |
|||
(objProp = pointInProp(expr.node, resolvePos(file, query.end)))) { |
|||
var name = objProp.key.name; |
|||
var fromCx = ensureObj(infer.typeFromContext(file.ast, expr)); |
|||
if (fromCx && fromCx.hasProp(name)) { |
|||
type = fromCx.hasProp(name); |
|||
} else { |
|||
var fromLocal = ensureObj(type); |
|||
if (fromLocal && fromLocal.hasProp(name)) |
|||
type = fromLocal.hasProp(name); |
|||
} |
|||
} |
|||
return type; |
|||
}; |
|||
|
|||
function findTypeAt(srv, query, file) { |
|||
var expr = findExpr(file, query), exprName; |
|||
var type = findExprType(srv, query, file, expr), exprType = type; |
|||
if (query.preferFunction) |
|||
type = type.getFunctionType() || type.getType(); |
|||
else |
|||
type = type.getType(); |
|||
|
|||
if (expr) { |
|||
if (expr.node.type == "Identifier") |
|||
exprName = expr.node.name; |
|||
else if (expr.node.type == "MemberExpression" && !expr.node.computed) |
|||
exprName = expr.node.property.name; |
|||
} |
|||
|
|||
if (query.depth != null && typeof query.depth != "number") |
|||
throw ternError(".query.depth must be a number"); |
|||
|
|||
var result = {guess: infer.didGuess(), |
|||
type: infer.toString(exprType, query.depth), |
|||
name: type && type.name, |
|||
exprName: exprName}; |
|||
if (type) storeTypeDocs(type, result); |
|||
if (!result.doc && exprType.doc) result.doc = exprType.doc; |
|||
|
|||
return clean(result); |
|||
} |
|||
|
|||
function findDocs(srv, query, file) { |
|||
var expr = findExpr(file, query); |
|||
var type = findExprType(srv, query, file, expr); |
|||
var result = {url: type.url, doc: type.doc, type: infer.toString(type)}; |
|||
var inner = type.getType(); |
|||
if (inner) storeTypeDocs(inner, result); |
|||
return clean(result); |
|||
} |
|||
|
|||
function storeTypeDocs(type, out) { |
|||
if (!out.url) out.url = type.url; |
|||
if (!out.doc) out.doc = type.doc; |
|||
if (!out.origin) out.origin = type.origin; |
|||
var ctor, boring = infer.cx().protos; |
|||
if (!out.url && !out.doc && type.proto && (ctor = type.proto.hasCtor) && |
|||
type.proto != boring.Object && type.proto != boring.Function && type.proto != boring.Array) { |
|||
out.url = ctor.url; |
|||
out.doc = ctor.doc; |
|||
} |
|||
} |
|||
|
|||
var getSpan = exports.getSpan = function(obj) { |
|||
if (!obj.origin) return; |
|||
if (obj.originNode) { |
|||
var node = obj.originNode; |
|||
if (/^Function/.test(node.type) && node.id) node = node.id; |
|||
return {origin: obj.origin, node: node}; |
|||
} |
|||
if (obj.span) return {origin: obj.origin, span: obj.span}; |
|||
}; |
|||
|
|||
var storeSpan = exports.storeSpan = function(srv, query, span, target) { |
|||
target.origin = span.origin; |
|||
if (span.span) { |
|||
var m = /^(\d+)\[(\d+):(\d+)\]-(\d+)\[(\d+):(\d+)\]$/.exec(span.span); |
|||
target.start = query.lineCharPositions ? {line: Number(m[2]), ch: Number(m[3])} : Number(m[1]); |
|||
target.end = query.lineCharPositions ? {line: Number(m[5]), ch: Number(m[6])} : Number(m[4]); |
|||
} else { |
|||
var file = srv.findFile(span.origin); |
|||
target.start = outputPos(query, file, span.node.start); |
|||
target.end = outputPos(query, file, span.node.end); |
|||
} |
|||
}; |
|||
|
|||
function findDef(srv, query, file) { |
|||
var expr = findExpr(file, query); |
|||
var type = findExprType(srv, query, file, expr); |
|||
if (infer.didGuess()) return {}; |
|||
|
|||
var span = getSpan(type); |
|||
var result = {url: type.url, doc: type.doc, origin: type.origin}; |
|||
|
|||
if (type.types) for (var i = type.types.length - 1; i >= 0; --i) { |
|||
var tp = type.types[i]; |
|||
storeTypeDocs(tp, result); |
|||
if (!span) span = getSpan(tp); |
|||
} |
|||
|
|||
if (span && span.node) { // refers to a loaded file
|
|||
var spanFile = span.node.sourceFile || srv.findFile(span.origin); |
|||
var start = outputPos(query, spanFile, span.node.start), end = outputPos(query, spanFile, span.node.end); |
|||
result.start = start; result.end = end; |
|||
result.file = span.origin; |
|||
var cxStart = Math.max(0, span.node.start - 50); |
|||
result.contextOffset = span.node.start - cxStart; |
|||
result.context = spanFile.text.slice(cxStart, cxStart + 50); |
|||
} else if (span) { // external
|
|||
result.file = span.origin; |
|||
storeSpan(srv, query, span, result); |
|||
} |
|||
return clean(result); |
|||
} |
|||
|
|||
function findRefsToVariable(srv, query, file, expr, checkShadowing) { |
|||
var name = expr.node.name; |
|||
|
|||
for (var scope = expr.state; scope && !(name in scope.props); scope = scope.prev) {} |
|||
if (!scope) throw ternError("Could not find a definition for " + name + " " + !!srv.cx.topScope.props.x); |
|||
|
|||
var type, refs = []; |
|||
function storeRef(file) { |
|||
return function(node, scopeHere) { |
|||
if (checkShadowing) for (var s = scopeHere; s != scope; s = s.prev) { |
|||
var exists = s.hasProp(checkShadowing); |
|||
if (exists) |
|||
throw ternError("Renaming `" + name + "` to `" + checkShadowing + "` would make a variable at line " + |
|||
(asLineChar(file, node.start).line + 1) + " point to the definition at line " + |
|||
(asLineChar(file, exists.name.start).line + 1)); |
|||
} |
|||
refs.push({file: file.name, |
|||
start: outputPos(query, file, node.start), |
|||
end: outputPos(query, file, node.end)}); |
|||
}; |
|||
} |
|||
|
|||
if (scope.originNode) { |
|||
type = "local"; |
|||
if (checkShadowing) { |
|||
for (var prev = scope.prev; prev; prev = prev.prev) |
|||
if (checkShadowing in prev.props) break; |
|||
if (prev) infer.findRefs(scope.originNode, scope, checkShadowing, prev, function(node) { |
|||
throw ternError("Renaming `" + name + "` to `" + checkShadowing + "` would shadow the definition used at line " + |
|||
(asLineChar(file, node.start).line + 1)); |
|||
}); |
|||
} |
|||
infer.findRefs(scope.originNode, scope, name, scope, storeRef(file)); |
|||
} else { |
|||
type = "global"; |
|||
for (var i = 0; i < srv.files.length; ++i) { |
|||
var cur = srv.files[i]; |
|||
infer.findRefs(cur.ast, cur.scope, name, scope, storeRef(cur)); |
|||
} |
|||
} |
|||
|
|||
return {refs: refs, type: type, name: name}; |
|||
} |
|||
|
|||
function findRefsToProperty(srv, query, expr, prop) { |
|||
var objType = infer.expressionType(expr).getObjType(); |
|||
if (!objType) throw ternError("Couldn't determine type of base object."); |
|||
|
|||
var refs = []; |
|||
function storeRef(file) { |
|||
return function(node) { |
|||
refs.push({file: file.name, |
|||
start: outputPos(query, file, node.start), |
|||
end: outputPos(query, file, node.end)}); |
|||
}; |
|||
} |
|||
for (var i = 0; i < srv.files.length; ++i) { |
|||
var cur = srv.files[i]; |
|||
infer.findPropRefs(cur.ast, cur.scope, objType, prop.name, storeRef(cur)); |
|||
} |
|||
|
|||
return {refs: refs, name: prop.name}; |
|||
} |
|||
|
|||
function findRefs(srv, query, file) { |
|||
var expr = findExprOrThrow(file, query, true); |
|||
if (expr && expr.node.type == "Identifier") { |
|||
return findRefsToVariable(srv, query, file, expr); |
|||
} else if (expr && expr.node.type == "MemberExpression" && !expr.node.computed) { |
|||
var p = expr.node.property; |
|||
expr.node = expr.node.object; |
|||
return findRefsToProperty(srv, query, expr, p); |
|||
} else if (expr && expr.node.type == "ObjectExpression") { |
|||
var pos = resolvePos(file, query.end); |
|||
for (var i = 0; i < expr.node.properties.length; ++i) { |
|||
var k = expr.node.properties[i].key; |
|||
if (k.start <= pos && k.end >= pos) |
|||
return findRefsToProperty(srv, query, expr, k); |
|||
} |
|||
} |
|||
throw ternError("Not at a variable or property name."); |
|||
} |
|||
|
|||
function buildRename(srv, query, file) { |
|||
if (typeof query.newName != "string") throw ternError(".query.newName should be a string"); |
|||
var expr = findExprOrThrow(file, query); |
|||
if (!expr || expr.node.type != "Identifier") throw ternError("Not at a variable."); |
|||
|
|||
var data = findRefsToVariable(srv, query, file, expr, query.newName), refs = data.refs; |
|||
delete data.refs; |
|||
data.files = srv.files.map(function(f){return f.name;}); |
|||
|
|||
var changes = data.changes = []; |
|||
for (var i = 0; i < refs.length; ++i) { |
|||
var use = refs[i]; |
|||
use.text = query.newName; |
|||
changes.push(use); |
|||
} |
|||
|
|||
return data; |
|||
} |
|||
|
|||
function listFiles(srv) { |
|||
return {files: srv.files.map(function(f){return f.name;})}; |
|||
} |
|||
|
|||
exports.version = "0.9.1"; |
|||
}); |
|||
@ -0,0 +1,359 @@ |
|||
// AST walker module for Mozilla Parser API compatible trees
|
|||
|
|||
(function(mod) { |
|||
if (typeof exports == "object" && typeof module == "object") return mod(exports); // CommonJS
|
|||
if (typeof define == "function" && define.amd) return define(["exports"], mod); // AMD
|
|||
mod((this.acorn || (this.acorn = {})).walk = {}); // Plain browser env
|
|||
})(function(exports) { |
|||
"use strict"; |
|||
|
|||
// A simple walk is one where you simply specify callbacks to be
|
|||
// called on specific nodes. The last two arguments are optional. A
|
|||
// simple use would be
|
|||
//
|
|||
// walk.simple(myTree, {
|
|||
// Expression: function(node) { ... }
|
|||
// });
|
|||
//
|
|||
// to do something with all expressions. All Parser API node types
|
|||
// can be used to identify node types, as well as Expression,
|
|||
// Statement, and ScopeBody, which denote categories of nodes.
|
|||
//
|
|||
// The base argument can be used to pass a custom (recursive)
|
|||
// walker, and state can be used to give this walked an initial
|
|||
// state.
|
|||
exports.simple = function(node, visitors, base, state) { |
|||
if (!base) base = exports.base; |
|||
function c(node, st, override) { |
|||
var type = override || node.type, found = visitors[type]; |
|||
base[type](node, st, c); |
|||
if (found) found(node, st); |
|||
} |
|||
c(node, state); |
|||
}; |
|||
|
|||
// An ancestor walk builds up an array of ancestor nodes (including
|
|||
// the current node) and passes them to the callback as the state parameter.
|
|||
exports.ancestor = function(node, visitors, base, state) { |
|||
if (!base) base = exports.base; |
|||
if (!state) state = []; |
|||
function c(node, st, override) { |
|||
var type = override || node.type, found = visitors[type]; |
|||
if (node != st[st.length - 1]) { |
|||
st = st.slice(); |
|||
st.push(node); |
|||
} |
|||
base[type](node, st, c); |
|||
if (found) found(node, st); |
|||
} |
|||
c(node, state); |
|||
}; |
|||
|
|||
// A recursive walk is one where your functions override the default
|
|||
// walkers. They can modify and replace the state parameter that's
|
|||
// threaded through the walk, and can opt how and whether to walk
|
|||
// their child nodes (by calling their third argument on these
|
|||
// nodes).
|
|||
exports.recursive = function(node, state, funcs, base) { |
|||
var visitor = funcs ? exports.make(funcs, base) : base; |
|||
function c(node, st, override) { |
|||
visitor[override || node.type](node, st, c); |
|||
} |
|||
c(node, state); |
|||
}; |
|||
|
|||
function makeTest(test) { |
|||
if (typeof test == "string") |
|||
return function(type) { return type == test; }; |
|||
else if (!test) |
|||
return function() { return true; }; |
|||
else |
|||
return test; |
|||
} |
|||
|
|||
function Found(node, state) { this.node = node; this.state = state; } |
|||
|
|||
// Find a node with a given start, end, and type (all are optional,
|
|||
// null can be used as wildcard). Returns a {node, state} object, or
|
|||
// undefined when it doesn't find a matching node.
|
|||
exports.findNodeAt = function(node, start, end, test, base, state) { |
|||
test = makeTest(test); |
|||
try { |
|||
if (!base) base = exports.base; |
|||
var c = function(node, st, override) { |
|||
var type = override || node.type; |
|||
if ((start == null || node.start <= start) && |
|||
(end == null || node.end >= end)) |
|||
base[type](node, st, c); |
|||
if (test(type, node) && |
|||
(start == null || node.start == start) && |
|||
(end == null || node.end == end)) |
|||
throw new Found(node, st); |
|||
}; |
|||
c(node, state); |
|||
} catch (e) { |
|||
if (e instanceof Found) return e; |
|||
throw e; |
|||
} |
|||
}; |
|||
|
|||
// Find the innermost node of a given type that contains the given
|
|||
// position. Interface similar to findNodeAt.
|
|||
exports.findNodeAround = function(node, pos, test, base, state) { |
|||
test = makeTest(test); |
|||
try { |
|||
if (!base) base = exports.base; |
|||
var c = function(node, st, override) { |
|||
var type = override || node.type; |
|||
if (node.start > pos || node.end < pos) return; |
|||
base[type](node, st, c); |
|||
if (test(type, node)) throw new Found(node, st); |
|||
}; |
|||
c(node, state); |
|||
} catch (e) { |
|||
if (e instanceof Found) return e; |
|||
throw e; |
|||
} |
|||
}; |
|||
|
|||
// Find the outermost matching node after a given position.
|
|||
exports.findNodeAfter = function(node, pos, test, base, state) { |
|||
test = makeTest(test); |
|||
try { |
|||
if (!base) base = exports.base; |
|||
var c = function(node, st, override) { |
|||
if (node.end < pos) return; |
|||
var type = override || node.type; |
|||
if (node.start >= pos && test(type, node)) throw new Found(node, st); |
|||
base[type](node, st, c); |
|||
}; |
|||
c(node, state); |
|||
} catch (e) { |
|||
if (e instanceof Found) return e; |
|||
throw e; |
|||
} |
|||
}; |
|||
|
|||
// Find the outermost matching node before a given position.
|
|||
exports.findNodeBefore = function(node, pos, test, base, state) { |
|||
test = makeTest(test); |
|||
if (!base) base = exports.base; |
|||
var max; |
|||
var c = function(node, st, override) { |
|||
if (node.start > pos) return; |
|||
var type = override || node.type; |
|||
if (node.end <= pos && (!max || max.node.end < node.end) && test(type, node)) |
|||
max = new Found(node, st); |
|||
base[type](node, st, c); |
|||
}; |
|||
c(node, state); |
|||
return max; |
|||
}; |
|||
|
|||
// Used to create a custom walker. Will fill in all missing node
|
|||
// type properties with the defaults.
|
|||
exports.make = function(funcs, base) { |
|||
if (!base) base = exports.base; |
|||
var visitor = {}; |
|||
for (var type in base) visitor[type] = base[type]; |
|||
for (var type in funcs) visitor[type] = funcs[type]; |
|||
return visitor; |
|||
}; |
|||
|
|||
function skipThrough(node, st, c) { c(node, st); } |
|||
function ignore(_node, _st, _c) {} |
|||
|
|||
// Node walkers.
|
|||
|
|||
var base = exports.base = {}; |
|||
base.Program = base.BlockStatement = function(node, st, c) { |
|||
for (var i = 0; i < node.body.length; ++i) |
|||
c(node.body[i], st, "Statement"); |
|||
}; |
|||
base.Statement = skipThrough; |
|||
base.EmptyStatement = ignore; |
|||
base.ExpressionStatement = base.ParenthesizedExpression = function(node, st, c) { |
|||
c(node.expression, st, "Expression"); |
|||
}; |
|||
base.IfStatement = function(node, st, c) { |
|||
c(node.test, st, "Expression"); |
|||
c(node.consequent, st, "Statement"); |
|||
if (node.alternate) c(node.alternate, st, "Statement"); |
|||
}; |
|||
base.LabeledStatement = function(node, st, c) { |
|||
c(node.body, st, "Statement"); |
|||
}; |
|||
base.BreakStatement = base.ContinueStatement = ignore; |
|||
base.WithStatement = function(node, st, c) { |
|||
c(node.object, st, "Expression"); |
|||
c(node.body, st, "Statement"); |
|||
}; |
|||
base.SwitchStatement = function(node, st, c) { |
|||
c(node.discriminant, st, "Expression"); |
|||
for (var i = 0; i < node.cases.length; ++i) { |
|||
var cs = node.cases[i]; |
|||
if (cs.test) c(cs.test, st, "Expression"); |
|||
for (var j = 0; j < cs.consequent.length; ++j) |
|||
c(cs.consequent[j], st, "Statement"); |
|||
} |
|||
}; |
|||
base.ReturnStatement = base.YieldExpression = function(node, st, c) { |
|||
if (node.argument) c(node.argument, st, "Expression"); |
|||
}; |
|||
base.ThrowStatement = base.SpreadElement = base.RestElement = function(node, st, c) { |
|||
c(node.argument, st, "Expression"); |
|||
}; |
|||
base.TryStatement = function(node, st, c) { |
|||
c(node.block, st, "Statement"); |
|||
if (node.handler) c(node.handler.body, st, "ScopeBody"); |
|||
if (node.finalizer) c(node.finalizer, st, "Statement"); |
|||
}; |
|||
base.WhileStatement = function(node, st, c) { |
|||
c(node.test, st, "Expression"); |
|||
c(node.body, st, "Statement"); |
|||
}; |
|||
base.DoWhileStatement = base.WhileStatement; |
|||
base.ForStatement = function(node, st, c) { |
|||
if (node.init) c(node.init, st, "ForInit"); |
|||
if (node.test) c(node.test, st, "Expression"); |
|||
if (node.update) c(node.update, st, "Expression"); |
|||
c(node.body, st, "Statement"); |
|||
}; |
|||
base.ForInStatement = base.ForOfStatement = function(node, st, c) { |
|||
c(node.left, st, "ForInit"); |
|||
c(node.right, st, "Expression"); |
|||
c(node.body, st, "Statement"); |
|||
}; |
|||
base.ForInit = function(node, st, c) { |
|||
if (node.type == "VariableDeclaration") c(node, st); |
|||
else c(node, st, "Expression"); |
|||
}; |
|||
base.DebuggerStatement = ignore; |
|||
|
|||
base.FunctionDeclaration = function(node, st, c) { |
|||
c(node, st, "Function"); |
|||
}; |
|||
base.VariableDeclaration = function(node, st, c) { |
|||
for (var i = 0; i < node.declarations.length; ++i) { |
|||
var decl = node.declarations[i]; |
|||
if (decl.init) c(decl.init, st, "Expression"); |
|||
} |
|||
}; |
|||
|
|||
base.Function = function(node, st, c) { |
|||
c(node.body, st, "ScopeBody"); |
|||
}; |
|||
base.ScopeBody = function(node, st, c) { |
|||
c(node, st, "Statement"); |
|||
}; |
|||
|
|||
base.Expression = skipThrough; |
|||
base.ThisExpression = ignore; |
|||
base.ArrayExpression = base.ArrayPattern = function(node, st, c) { |
|||
for (var i = 0; i < node.elements.length; ++i) { |
|||
var elt = node.elements[i]; |
|||
if (elt) c(elt, st, "Expression"); |
|||
} |
|||
}; |
|||
base.ObjectExpression = base.ObjectPattern = function(node, st, c) { |
|||
for (var i = 0; i < node.properties.length; ++i) |
|||
c(node.properties[i], st); |
|||
}; |
|||
base.FunctionExpression = base.ArrowFunctionExpression = base.FunctionDeclaration; |
|||
base.SequenceExpression = base.TemplateLiteral = function(node, st, c) { |
|||
for (var i = 0; i < node.expressions.length; ++i) |
|||
c(node.expressions[i], st, "Expression"); |
|||
}; |
|||
base.UnaryExpression = base.UpdateExpression = function(node, st, c) { |
|||
c(node.argument, st, "Expression"); |
|||
}; |
|||
base.BinaryExpression = base.AssignmentExpression = base.AssignmentPattern = base.LogicalExpression = function(node, st, c) { |
|||
c(node.left, st, "Expression"); |
|||
c(node.right, st, "Expression"); |
|||
}; |
|||
base.ConditionalExpression = function(node, st, c) { |
|||
c(node.test, st, "Expression"); |
|||
c(node.consequent, st, "Expression"); |
|||
c(node.alternate, st, "Expression"); |
|||
}; |
|||
base.NewExpression = base.CallExpression = function(node, st, c) { |
|||
c(node.callee, st, "Expression"); |
|||
if (node.arguments) for (var i = 0; i < node.arguments.length; ++i) |
|||
c(node.arguments[i], st, "Expression"); |
|||
}; |
|||
base.MemberExpression = function(node, st, c) { |
|||
c(node.object, st, "Expression"); |
|||
if (node.computed) c(node.property, st, "Expression"); |
|||
}; |
|||
base.ExportDeclaration = function (node, st, c) { |
|||
c(node.declaration, st); |
|||
}; |
|||
base.ImportDeclaration = function (node, st, c) { |
|||
node.specifiers.forEach(function (specifier) { |
|||
c(specifier, st); |
|||
}); |
|||
}; |
|||
base.ImportSpecifier = base.ImportBatchSpecifier = base.Identifier = base.Literal = ignore; |
|||
|
|||
base.TaggedTemplateExpression = function(node, st, c) { |
|||
c(node.tag, st, "Expression"); |
|||
c(node.quasi, st); |
|||
}; |
|||
base.ClassDeclaration = base.ClassExpression = function(node, st, c) { |
|||
if (node.superClass) c(node.superClass, st, "Expression"); |
|||
for (var i = 0; i < node.body.body.length; i++) |
|||
c(node.body.body[i], st); |
|||
}; |
|||
base.MethodDefinition = base.Property = function(node, st, c) { |
|||
if (node.computed) c(node.key, st, "Expression"); |
|||
c(node.value, st, "Expression"); |
|||
}; |
|||
base.ComprehensionExpression = function(node, st, c) { |
|||
for (var i = 0; i < node.blocks.length; i++) |
|||
c(node.blocks[i].right, st, "Expression"); |
|||
c(node.body, st, "Expression"); |
|||
}; |
|||
|
|||
// NOTE: the stuff below is deprecated, and will be removed when 1.0 is released
|
|||
|
|||
// A custom walker that keeps track of the scope chain and the
|
|||
// variables defined in it.
|
|||
function makeScope(prev, isCatch) { |
|||
return {vars: Object.create(null), prev: prev, isCatch: isCatch}; |
|||
} |
|||
function normalScope(scope) { |
|||
while (scope.isCatch) scope = scope.prev; |
|||
return scope; |
|||
} |
|||
exports.scopeVisitor = exports.make({ |
|||
Function: function(node, scope, c) { |
|||
var inner = makeScope(scope); |
|||
for (var i = 0; i < node.params.length; ++i) |
|||
inner.vars[node.params[i].name] = {type: "argument", node: node.params[i]}; |
|||
if (node.id) { |
|||
var decl = node.type == "FunctionDeclaration"; |
|||
(decl ? normalScope(scope) : inner).vars[node.id.name] = |
|||
{type: decl ? "function" : "function name", node: node.id}; |
|||
} |
|||
c(node.body, inner, "ScopeBody"); |
|||
}, |
|||
TryStatement: function(node, scope, c) { |
|||
c(node.block, scope, "Statement"); |
|||
if (node.handler) { |
|||
var inner = makeScope(scope, true); |
|||
inner.vars[node.handler.param.name] = {type: "catch clause", node: node.handler.param}; |
|||
c(node.handler.body, inner, "ScopeBody"); |
|||
} |
|||
if (node.finalizer) c(node.finalizer, scope, "Statement"); |
|||
}, |
|||
VariableDeclaration: function(node, scope, c) { |
|||
var target = normalScope(scope); |
|||
for (var i = 0; i < node.declarations.length; ++i) { |
|||
var decl = node.declarations[i]; |
|||
target.vars[decl.id.name] = {type: "var", node: decl.id}; |
|||
if (decl.init) c(decl.init, scope, "Expression"); |
|||
} |
|||
} |
|||
}); |
|||
|
|||
}); |
|||
Loading…
Reference in new issue