Oracle International Corporation

Oracle Intemnational Corporation

Daniel Smith

Maurizio Cimadamore

Brian Goetz

John Robert Rose

Alexander R Buckley

Lai Hung Mandy Chung

David Colin Holmes

Frederic Parain

Techniques for determining and displaying error messages including a cause of an error generated because two types are not members of the same nest are disclosed. The system detects, at runtime, an instruction in a first type that attempts to access a private member of a second type. The system evaluates one or more nestmate criteria to determine whether the first type and the second type are within a same nest. A nest host corresponding to the nest specifies each nest member of the nest, and each nest member specifies an association with the nest. Responsive to determining that a particular nestmate criterion is not met, the system determines that the first type and the second type are not within the same nest and records or displays data identifying the particular nestmate criterion that has not been met, and throws an access error.

Distinguished nest-based access control

A data structure (e.g., field, method parameter, or method return value) is defined by a descriptor to be of a particular type, which imposes a first set of restrictions on values assumable by the data structure. Separately, the data structure is associated with a type restriction that defines a second set of restrictions that further restricts the values assumable by the data structure. The descriptor and type restriction are encoded separately in a program binary. Responsive to identifying a value for the data structure that (a) is not forbidden by the first set of restrictions defined the descriptor and (b) is forbidden by the second set of restrictions defined by the type restriction, a runtime environment may perform a restrictive operation, such as: blocking storage of the value to a field; blocking passing of the value to a method parameter; or blocking return of the value from a method.

Dynamically-imposed field and method type restrictions for managed execution environments

Operations include (a) identifying bounds corresponding to two or more inference variables corresponding to a nested method invocation context, (b) determining that resolution of a first inference variable can be determined as a function of a resolution of a second inference variable, (c) propagating bounds corresponding to the second inference variable from the nested method invocation context to an outer method invocation context without propagating bounds corresponding to the first inference variable, (d) resolving a constraint set to resolve the second inference variable, and (e) resolving the first inference variable based on the resolution of the second inference variable.

Type inference optimization

A system and method can support compatibility checking in a programming language environment. The programming language environment can check whether a target type associated with an expression in the programming language environment is functional, wherein the target type is functional when it has exactly one method meeting one or more criteria that define that method as relevant in a counting system. Then, the programming language environment can derive a function descriptor from the target type, which is context-dependent. Furthermore, the programming language environment can type-check the expression with the function descriptor associated with the target type.

System and method for supporting compatibility checking for lambda expression

A compiler may perform type checking as part of analyzing source code. The type checking may include existential type packing for structurally-restricted existential types. At compile time, the compiler may need to use an existential type that does not conform to the language's structural rules. The compiler may apply the 'pack' operation described herein to produce a supertype of the desired existential type that does conform to the language's structural rules, and thus can be used as an approximation of the desired type. The compiler may then perform additional type checking using the resulting type.

Existential type packing for structurally-restricted existential types

In accordance with various embodiments, systems and methods are provided which facilitate inferring immutability of variables. A compiler analyzes local variables within source code to determine whether they are immutable. In particular embodiments the compiler examines locations where each variable is assigned to determine whether the variable was definitely unassigned before the assignment. Because the compiler can infer whether a local variable is immutable, it is possible for the programmer to avoid using a keyword to expressly declare the local variable as immutable. Inferring immutability of variables, thus, maintains correctness of the compiled code while reducing the burden on the programmer.

System and method for inferring immutability of program variables

Methods and apparatus for target typing of overloaded method and constructor arguments are described. A method comprises determining whether source code of a program includes, as an argument to an overloaded operation invocation, an expression whose type is context-dependent. The method further comprises, if the source code includes such an argument, providing the expression as an input to an overload resolver, and determining at the overload resolver whether (a) each argument of the invocation is compatible with types of corresponding parameters in one or more declarations and (b) whether a particular declaration among such a set of declarations can be identified as the most specific. If both conditions are met, the method comprises generating executable instructions for the invocation.

Target typing of overloaded method and constructor arguments

A system and method can support context-dependent expression compilation in a programming language environment. A compiler in the programming language environment can provide one or more context objects that operate to compile various context-dependent expressions in different programming contexts. Then, the compiler can use a said context object to derive a target type associated with a context-dependent expression, and use the context object to perform compatibility check for the context-dependent expression in the programming language environment.

Growing community of inventors

Spanish Fork, UT, United States of America

Daniel Smith