JScript Blog : JScript Intellisense

Versioning Language Features in JScript

GauravS — Fri, 17 Apr 2009 01:58:00 GMT

With Internet Explorer 8 we introduced several new JScript language features including native JSON support and accessor methods for Mutable DOM prototypes. Of course, any new language feature introduces compatibility risk and one of the main pieces of feedback we received was that we needed to provide a smart way for developers to opt in or out of these new language features.

So in the JScript engine shipped as a part of Internet Explorer 8, we introduced a versioning switch which enables developers to choose the JScript language set they want to support. Web developers can opt-in/opt-out of select JScript language features by using IE8’s Document Compatibility, which depends upon the layout (or document) mode in which web content is loaded.

Potential Issue: Example

As an example, let’s look at IE8’s native JSON support. We added this support to the engine by adding a global JSON object with built-in parse() and stringify() methods, as per the draft ES3.1 specification, now called the ECMAScript Fifth Edition. Now, for the sake of example, let us pretend that the JScript engine did not allow language versioning and a site implemented a JSON call like this:

1: if(!this.JSON) // check for non-existence of JSON object/functions

2: {

3: //<define a JSON object>

4: //<define a non-standard compliant encoder function – JSON.encode>

5: //<define a non-standard compliant parser function – JSON.parse>

6: }

8: //somewhere in the code

9: JSON.encode(myObj);

For IE7, since no JSON object existed by default, the if check would evaluate to true and the user defined JSON object and encoder/decoder methods would be defined. The call to JSON.encode() would work as wanted.

However, for IE8, the existence of the native JSON object would cause the if check to evaluate to false and no user defined method would be available. The call to JSON.encode() would now fail, which would produce unexpected application behavior, since no such method was defined.

JScript Versioning in Internet Explorer 8 (for Web Developers)

Web developers can now avoid such issues by choosing an appropriate layout (or document) mode for their content. Choosing the layout mode as “Internet Explorer 8 Standards Mode” opts in to the JScript language features supported by version 5.8 JScript engine. Choosing the layout mode to be any mode other than the “Internet Explorer 8 Standards” mode, would imply an opt-in to support JScript language feature set equivalent to the one shipped in version 5.7 of the JScript engine (equivalent to the one shipped in IE7). Going back to the example above, the site owner can either update the code to start taking advantage of native JSON support and use the “Internet Explorer 8 Standards” mode, or can choose any other layout mode to use the existing code as is, thus maintaining compatibility with IE7.

While a dependency on the document mode implies that developers will need to make a switch to both IE and JScript level features and can’t single out/opt-in only to the JScript changes, we did not want to introduce a new version vector specifically for the JScript engine. We wanted to support the same system used by IE8 overall for standards support.

You could read more about IE8’s Compatibility View feature in Scott Dicken’s blog Just The Facts: Recap of Compatibility View and the MSDN documentation for Defining Document Compatibility.

JScript Versioning in other JScript Hosts (for JScript Host Developers)

Apart from Internet Explorer, there are various other hosts such as Windows Script Host, CScript etc. which host the JScript engine, To avoid similar compatibility issues and enable hosts to choose a particular JScript language feature set, the JScript engine now exposes an IActiveScriptProperty::SCRIPTPROP_INVOKEVERSIONING property.

To opt in to a set of language features that should be supported by the JScript script engine, the host needs to invoke the IActiveScriptProperty::SetProperty and set SCRIPTPROP_INVOKEVERSIONING to one of the values below during the engine initialization:

1 (or SCRIPTLANGUAGEVERSION_5_7): To use the language features equivalent to those shipped in Version 5.7 (or IE7) of the JScript engine
2 (or SCRIPTLANGUAGEVERSION_5_8): To use the language features available in Version 5.8 (or IE8) of the JScript script engine. This includes features available in version 5.7 and the language changes introduced in version 5.8.

By default, the set of language features supported by the JScript script engine is set to 0 (or SCRIPTLANGUAGEVERSION_DEFAULT), equivalent to the language feature set shipped in version 5.7 of the JScript engine, unless the host chooses to support a different default behavior.

List of features versioned

Right now, only nine JScript features are versioned like this:

Native JSON support – This would introduce a new built-in JSON object, and the following built-in methods – JSON.parse(), JSON.stringify(), Date.toJSON(), Number.toJSON(), Boolean.toJSON() and String.toJSON()
Support for accessor methods for enabling Document Object Model prototypes
Default the separator to “,” if the separator value is ‘undefined’ in Array.prototype.join
Return the length of the resultant array instead of ‘undefined’ for Array.prototype.unshift
Call toString() if precision is ‘undefined’ instead of throwing a “RangeError” for Number.prototype.toPrecision
Support for array subclassing
Support for trailing commas in object literals
Implemented Error.prototype.toString to provide better error messages
Support for index operator [] on string values

I hope JScript versioning will help ensure that the IE8 end user experience is compatible with IE7 and will give developers some time to update their code to take advantage of these new language enhancements.

Gaurav Seth

Program Manager, JScript

Writing for JScript Intellisense in VS 2008

Sameerch — Thu, 08 Nov 2007 09:15:00 GMT

Since we release JSript intellisense in Visual Studio 2008 Beta 2, there has been some queries on why JScript intellisense behaves in a certain way. I wish to tell you that intellisense in a dynamic language like JScript is based on certain heuristics. We try our best to guess the runtime behavior and provide what we think is the best guess. As such, it is not always what a user might expect.

To illustrate, consider the following example:

 1: Person = function() {
 2:     this.name = “Anonymous”;
 3: }
 4:
 5: Person.prototype = {
 6:     getName : function() {
 7:         return this.name;               // I don’t see “name” on the list
 8:     }
 9: }

When we type “this.” In line 7, we don’t see “name” in the intellisense dropdown that pops up. This is contrary to what a user might expect. But consider the following usage:

10: Person.prototype.getName();

In this case, we get an undefined value since “name” is not defined in this context. So, it is not always the case that “name” would be defined. To avoid such ambiguity, the above can be modified so that all variables are defined in the prototype:

11: Person = function() { }
12:
13: Person.prototype = {
14:     name : “Anonymous”,
15:     getName : function() {
16:         return this.name;               // I see “name” on the list now
17:     }
18: }

Now, you can see “name” in the intellisense drop down.

Update 11/12/2007: There have been some recent comments on this post which rightly point out that there is a functionality difference between the two. The difference is subtle. And, if you are unsure of the functionality difference , I would suggest that you start by reading this post on Classes in Jscript by Ritesh.

Sameer

Javascript Intellisense and Coloring Issues in VS 2008 Beta 2

Sameerch — Mon, 24 Sep 2007 22:30:00 GMT

We have come across a couple of installation issues in VS 2008 Beta 2 which broke the new Javascript functionalities in certain scenarios. While a workaround has already been provided in the online refresh of the ReadMe text, I thought I would also put it down here in case any of you hit the problem.

Issues

We faced two installation issues which broke Jscript functionality in VS 2008 Beta 2

Uninstallation of Silverlight Tools for Visual Studio 2008 Beta 1 removes the Jscript Authoring DLL
Installation of Team Explorer Beta 2 corrupts the registration of Jscript

In either case, you dont get to see Javascript intellisense, syntax errors, and javascript coloring does not work.

Workaround

The recommended workaround for both the issues is to Repair the Visual Studio installation by running setup again. The first issue can be avoided by uninstalling SL Tools for VS Beta1 before installing VS 2008 Beta 2. The second issue can also be fixed if you dont mind fiddling with the registry. See the blog post here for details.

Sameer

Javascript Intellisense in VS 2008 for Silverlight 1.0

Sameerch — Tue, 07 Aug 2007 13:52:00 GMT

Javascript Intellisense is one of the major improvements in Visual Studio 2008 Beta 2. There is a nice project that extends the javascript intellisense experience for Silverlight 1.0 by Justin. With this extension, developers will experience full javascript intellisense in VS 2008 while developing applications for Silverlight 1.0.

Default Javascript Intellisense in VS 2008 Beta 2

Javascript Intellisense in VS 2008 Beta 2 with Justin's project

As you can see, you get much more intellisense. Follow up his blog for more.

Visual Studio 2008 Beta 2 Released!

Sameerch — Wed, 01 Aug 2007 14:37:00 GMT

You probably know by now. Microsoft has announced the release of Visual Studio 2008 Beta 2 and Visual Web Developer 2008 Beta 2. The release incorporates improvments to Javascript intellisense, apart from making Javascript errors available through the error tab. I will probably write more on this later.

Meanwhile, Alex has written about an installation problem in which might lead to non availability of these features in Visual Studio, and the workaround for restoring the full functionality. The issue lies in the Jscript engine not being registered peoperly. In case you hit such a problem, check out the blog here.

JScript Authoring Support in Visual Studio "Orcas" - Part II

Sameerch — Fri, 02 Mar 2007 16:22:00 GMT

Last month, I talked about the new Intellisense for the JScript language. Well, the March CTP is available for you to check out this feature. Jeff from the Web Tools team, our partner in implementing this feature, has also published a very nice post that gives an aerial tour of the intellisense features. That should really get you started on this.

I said I will talk about script references in the next blog, but Jeff's blog sufficiently covers most parts of it. So, I will leave that for another day. Meanwhile, download the CTP and give us your feedback.

Watch out for JScript Authoring Support in Visual Studio "Orcas" - Part I

Sameerch — Sat, 10 Feb 2007 22:41:00 GMT

Hello, I am Sameer Chabungbam. For living, I work as a Program Manager in the JScript team at Microsoft. This team, among other things, has been working for sometime now to incorporate a good design time support for the JScript language in Visual Studio Orcas release. I would be writing about what we have been doing for the last few months. This is the first, and here, I would talk about Intellisense.

Enhanced Intellisense for JScript

Up until now, Intellisense support for Jscript in Visual Studio has been very limited. With the Orcas release, Visual Studio would provide smarter and better intellisense. These include:

Expanded Global list
Inferencing
Script References

Global List has been expanded to include keywords and local variables. The list would also take care of providing the right scoping. That is, it would present only the symbols which are present in the current scope.

Inferencing

The best feature, in my opinion, about the new Intellisense support is that we have a lot smarter intellisense. It is now able to infer the correct types in many scenarios. Consider the following examples.

An example of inference through assignments:

    var d1, d2, d3;

    d1 = new Date();
    exec_task();
    d2 = new Date();

    d3 = d2 - d1;
    d3.

At this point, intellisense completion list would correctly contain the members of a number.

Here is an example of inference through function return values:

    function compute_time(exec_task)
    {
        var d1, d2, d3;

        d1 = new Date();
        exec_task();
        d2 = new Date();

        d3 = d2 - d1;
        return d3;
    }

    compute_time(myfunc).

Again, here, we get a smarter intellisense for number. There are many scenarios in which we get better intellisense. Do download the next CTP release of Visual Studio and check out this new intellisense for JScript.

In the next part, I would write about the Intellisense through Script references.