Program,

Module,

WebAssembly,

JSON,

Text,

ImportMap,

CSS,

WTF_MAKE_NONCOPYABLE(LineStartTable);

LineStartTable() = default;

// Positions within the provider's own text. An inline <script> starts partway into its

// document, and that offset is not applied here.

struct PositionInfo {

unsigned line0Based { 0 };

unsigned column0Based { 0 };

unsigned lineStart { 0 };

unsigned lineEnd { 0 }; // excludes the line terminator, so [lineStart, lineEnd) is the text

};

JS_EXPORT_PRIVATE PositionInfo positionInfoForOffset(StringView text, unsigned offset);

// Out-of-range input clamps rather than fails: a line past the end gives the end of the text,

// and a column past the end of its line gives that line's end.

JS_EXPORT_PRIVATE unsigned offsetForPosition(StringView text, unsigned line0Based, unsigned column0Based);

JS_EXPORT_PRIVATE LineColumn zeroBasedLineColumnForOffset(const SourceProvider&, unsigned offset);

bool isBuilt() const

{

Locker locker { m_lock };

return !!m_lineStarts;

}

template<typename CharType> static Vector<unsigned> build(std::span<const CharType>);

const Vector<unsigned>& ensureBuilt(StringView) WTF_REQUIRES_LOCK(m_lock);

mutable Lock m_lock;

std::optional<Vector<unsigned>> m_lineStarts WTF_GUARDED_BY_LOCK(m_lock);

unsigned m_builtForLength WTF_GUARDED_BY_LOCK(m_lock) { 0 };

static const intptr_t nullID = 1;

JS_EXPORT_PRIVATE SourceProvider(const SourceOrigin&, String&& sourceURL, String&& preRedirectURL, SourceTaintedness, const TextPosition& startPosition, SourceProviderSourceType);

JS_EXPORT_PRIVATE virtual ~SourceProvider();

virtual unsigned hash() const = 0;

virtual StringView source() const = 0;

virtual RefPtr<CachedBytecode> cachedBytecode() const { return nullptr; }

virtual void cacheBytecode(const BytecodeCacheGenerator&) const { }

virtual void updateCache(const UnlinkedFunctionExecutable*, const SourceCode&, CodeSpecializationKind, const UnlinkedFunctionCodeBlock*) const { }

virtual void commitCachedBytecode() const { }

StringView getRange(int start, int end) const LIFETIME_BOUND

{

return source().substring(start, end - start);

}

const SourceOrigin& sourceOrigin() const LIFETIME_BOUND { return m_sourceOrigin; }

// This is NOT the path that should be used for computing relative paths from a script. Use SourceOrigin's URL for that, the values may or may not be the same...

const String& sourceURL() const LIFETIME_BOUND { return m_sourceURL; }

const String& sourceURLStripped();

const String& preRedirectURL() const LIFETIME_BOUND { return m_preRedirectURL; }

const String& sourceURLDirective() const LIFETIME_BOUND { return m_sourceURLDirective; }

const String& sourceMappingURLDirective() const LIFETIME_BOUND { return m_sourceMappingURLDirective; }

TextPosition startPosition() const { return m_startPosition; }

SourceProviderSourceType sourceType() const { return m_sourceType; }

bool isModuleType() const

{

switch (m_sourceType) {

case SourceProviderSourceType::Module:

case SourceProviderSourceType::JSON:

case SourceProviderSourceType::Text:

case SourceProviderSourceType::CSS:

return true;

default:

return false;

}

}

SourceID asID()

{

if (!m_id)

getID();

return m_id;

}

void setSourceURLDirective(const String& sourceURLDirective) { m_sourceURLDirective = sourceURLDirective; }

void setSourceMappingURLDirective(const String& sourceMappingURLDirective) { m_sourceMappingURLDirective = sourceMappingURLDirective; }

void setSourceTaintedOrigin(SourceTaintKind kind, SourceTaintedOrigin taintedness) { m_taintedness[kind] = taintedness; }

SourceTaintedness taintedness() const { return m_taintedness; }

SourceTaintedOrigin sourceTaintedOrigin(SourceTaintKind kind) const { return m_taintedness[kind]; }

bool LEGACY_NODELETE couldBeTainted() const { return m_taintedness.couldBeTainted(); }

JS_EXPORT_PRIVATE void lockUnderlyingBuffer();

JS_EXPORT_PRIVATE void unlockUnderlyingBuffer();

JS_EXPORT_PRIVATE CodeBlockHash codeBlockHashConcurrently(int startOffset, int endOffset, CodeSpecializationKind) const;

// Like source(), but safe on any thread. The text is valid only during the call.

JS_EXPORT_PRIVATE virtual void withSourceConcurrently(const ScopedLambda<void(StringView)>&) const;

virtual bool isScriptBufferSourceProvider() const { return false; }

JS_EXPORT_PRIVATE UTF8CString sourceCodeDumpFilePath(const UTF8CString& dumpDirectory);

LineStartTable::PositionInfo positionInfoForOffset(unsigned offset)

{

// Reads source(), which is unsafe on GC threads. documentLineColumnForOffset() is a thread-safe option.

ASSERT(Thread::currentSingleton().gcThreadType() == GCThreadType::None);

return m_lineStartTable.positionInfoForOffset(source(), offset);

}

unsigned offsetForPosition(unsigned line0Based, unsigned column0Based)

{

ASSERT(Thread::currentSingleton().gcThreadType() == GCThreadType::None);

return m_lineStartTable.offsetForPosition(source(), line0Based, column0Based);

}

// An inline <script> shifts every line of its document, but shifts the column only on its first

// line, since later lines begin where their own line begins.

LineColumn documentZeroBasedLineColumnForOffset(unsigned offset)

{

auto position = m_lineStartTable.zeroBasedLineColumnForOffset(*this, offset);

return {

m_startPosition.m_line.zeroBasedInt() + position.line,

position.line ? position.column : m_startPosition.m_column.zeroBasedInt() + position.column,

};

}

LineColumn documentLineColumnForOffset(unsigned offset)

{

auto position = documentZeroBasedLineColumnForOffset(offset);

return { position.line + 1, position.column + 1 };

}

bool lineStartTableIsBuilt() const { return m_lineStartTable.isBuilt(); }

JS_EXPORT_PRIVATE virtual void lockUnderlyingBufferImpl();

JS_EXPORT_PRIVATE virtual void unlockUnderlyingBufferImpl();

JS_EXPORT_PRIVATE void LEGACY_NODELETE getID();

std::atomic<unsigned> m_lockingCount { 0 };

SourceProviderSourceType m_sourceType;

SourceOrigin m_sourceOrigin;

String m_sourceURL;

String m_sourceURLStripped;

String m_preRedirectURL;

String m_sourceURLDirective;

String m_sourceMappingURLDirective;

TextPosition m_startPosition;

SourceID m_id { 0 };

SourceTaintedness m_taintedness;

std::atomic<bool> m_sourceCodeDumped { false };

Lock m_sourceCodeDumpLock;

UTF8CString m_sourceCodeDumpFilePath WTF_GUARDED_BY_LOCK(m_sourceCodeDumpLock);

LineStartTable m_lineStartTable;

WTF_DEPRECATED_MAKE_FAST_ALLOCATED_WITH_HEAP_IDENTIFIER(StringSourceProvider, StringSourceProvider);

static Ref<StringSourceProvider> create(const String& source, const SourceOrigin& sourceOrigin, String sourceURL, SourceTaintedness taintedness, const TextPosition& startPosition = TextPosition(), SourceProviderSourceType sourceType = SourceProviderSourceType::Program)

{

return adoptRef(*new StringSourceProvider(source, sourceOrigin, taintedness, WTF::move(sourceURL), startPosition, sourceType));

}

unsigned hash() const override

{

return m_source.get().hash();

}

StringView source() const override

{

return m_source.get();

}

StringSourceProvider(const String& source, const SourceOrigin& sourceOrigin, SourceTaintedness taintedness, String&& sourceURL, const TextPosition& startPosition, SourceProviderSourceType sourceType)

: SourceProvider(sourceOrigin, WTF::move(sourceURL), String(), taintedness, startPosition, sourceType)

, m_source(source.isNull() ? *StringImpl::empty() : *source.impl())

{

}

const Ref<StringImpl> m_source;

virtual const uint8_t* data() = 0;

virtual size_t size() const = 0;

JS_EXPORT_PRIVATE BaseWebAssemblySourceProvider(const SourceOrigin&, String&& sourceURL);

static Ref<WebAssemblySourceProvider> create(Vector<uint8_t>&& data, const SourceOrigin& sourceOrigin, String sourceURL)

{

return adoptRef(*new WebAssemblySourceProvider(WTF::move(data), sourceOrigin, WTF::move(sourceURL)));

}

unsigned hash() const final

{

return m_source.impl()->hash();

}

StringView source() const final

{

return m_source;

}

const uint8_t* data() final

{

return m_data.span().data();

}

size_t size() const final

{

return m_data.size();

}

const Vector<uint8_t>& dataVector() const

{

return m_data;

}

WebAssemblySourceProvider(Vector<uint8_t>&& data, const SourceOrigin& sourceOrigin, String&& sourceURL)

: BaseWebAssemblySourceProvider(sourceOrigin, WTF::move(sourceURL))

, m_source("[WebAssembly source]"_s)

, m_data(WTF::move(data))

{

}

String m_source;

Vector<uint8_t> m_data;

explicit SourceProviderBufferGuard(SourceProvider* sourceProvider)

: m_sourceProvider(sourceProvider)

{

if (m_sourceProvider)

m_sourceProvider->lockUnderlyingBuffer();

}

~SourceProviderBufferGuard()

{

if (m_sourceProvider)

m_sourceProvider->unlockUnderlyingBuffer();

}

SourceProvider* provider() { return m_sourceProvider; }

// This must not be RefPtr. It is possible that this is used by the concurrent compiler and

// we are ensuring that this does not go away with different mechanism. But SourceProvider etc. can have main-thread-only affinity.

SourceProvider* m_sourceProvider { nullptr };